Enum rustc_mir::borrow_check::type_check::Locations

pub enum Locations {
    All(Span),
    Single(Location),
}

The Locations type summarizes where region constraints are required to hold. Normally, this is at a particular point which created the obligation, but for constraints that the user gave, we want the constraint to hold at all points.

Variants

All(Span)

Indicates that a type constraint should always be true. This is particularly important in the new borrowck analysis for things like the type of the return slot. Consider this example:

fn foo<'a>(x: &'a u32) -> &'a u32 {
    let y = 22;
    return &y; // error
}

Here, we wind up with the signature from the return type being something like &'1 u32 where '1 is a universal region. But the type of the return slot _0 is something like &'2 u32 where '2 is an existential region variable. The type checker requires that &'2 u32 = &'1 u32 -- but at what point? In the older NLL analysis, we required this only at the entry point to the function. By the nature of the constraints, this wound up propagating to all points reachable from start (because '1 -- as a universal region -- is live everywhere). In the newer analysis, though, this doesn't work: _0 is considered dead at the start (it has no usable value) and hence this type equality is basically a no-op. Then, later on, when we do _0 = &'3 y, that region '3 never winds up related to the universal region '1 and hence no error occurs. Therefore, we use Locations::All instead, which ensures that the '1 and '2 are equal everything. We also use this for other user-given type annotations; e.g., if the user wrote let mut x: &'static u32 = ..., we would ensure that all values assigned to x are of 'static lifetime.

The span points to the place the constraint arose. For example, it points to the type in a user-given type annotation. If there's no sensible span then it's DUMMY_SP.

Single(Location)

An outlives constraint that only has to hold at a single location, usually it represents a point where references flow from one spot to another (e.g., x = y)

Implementations

impl Locations

pub fn from_location(&self) -> Option<Location>

pub fn span(&self, body: &Body<'_>) -> Span

Gets a span representing the location.

Trait Implementations

impl Clone for Locations

pub fn clone(&self) -> Locations

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Locations

impl Debug for Locations

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Locations

impl Hash for Locations

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl NormalizeLocation for Locations

pub(in borrow_check::type_check) fn to_locations(
    self
) -> Locations

impl Ord for Locations

pub fn cmp(&self, other: &Locations) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

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

Restrict a value to a certain interval.

impl PartialEq<Locations> for Locations

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

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

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

This method tests for !=.

impl PartialOrd<Locations> for Locations

pub fn partial_cmp(&self, other: &Locations) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

pub fn lt(&self, other: &Locations) -> bool

This method tests less than (for self and other) and is used by the < operator.

pub fn le(&self, other: &Locations) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

pub fn gt(&self, other: &Locations) -> bool

This method tests greater than (for self and other) and is used by the > operator.

pub fn ge(&self, other: &Locations) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralEq for Locations

impl StructuralPartialEq for Locations