Enum rustc_mir::borrow_check::nll::universal_regions::RegionClassification

pub enum RegionClassification {
    Global,
    External,
    Local,
}

🔬 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?

Variants

Global

🔬 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?

A global region is one that can be named from anywhere. There is only one, 'static.

External

🔬 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?

An external region is only relevant for closures. In that case, it refers to regions that are free in the closure type -- basically, something bound in the surrounding context.

Consider this example:

fn foo<'a, 'b>(a: &'a u32, b: &'b u32, c: &'static u32) {
  let closure = for<'x> |x: &'x u32| { .. };
                ^^^^^^^ pretend this were legal syntax
                        for declaring a late-bound region in
                        a closure signature
}

Here, the lifetimes 'a and 'b would be external to the closure.

If we are not analyzing a closure, there are no external lifetimes.

Local

🔬 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?

A local lifetime is one about which we know the full set of relevant constraints (that is, relationships to other named regions). For a closure, this includes any region bound in the closure's signature. For a fn item, this includes all regions other than global ones.

Continuing with the example from External, if we were analyzing the closure, then 'x would be local (and 'a and 'b are external). If we are analyzing the function item foo, then 'a and 'b are local (and 'x is not in scope).

Trait Implementations

impl Copy for RegionClassification

impl Clone for RegionClassification

fn clone(&self) -> RegionClassification

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RegionClassification

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl PartialEq for RegionClassification

fn eq(&self, other: &RegionClassification) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Eq for RegionClassification

fn assert_receiver_is_total_eq(&self)

impl Hash for RegionClassification

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

Feeds a slice of this type into the given [Hasher].