Enum rustc_borrowck::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

fn clone(&self) -> Locations

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Locations

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

Formats the value using the given formatter.

impl Hash for Locations

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl NormalizeLocation for Locations

fn to_locations(self) -> Locations

impl Ord for Locations

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Locations

fn eq(&self, other: &Locations) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Locations

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

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

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

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

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

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

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

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

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

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

impl Copy for Locations

impl Eq for Locations

impl StructuralPartialEq for Locations

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 16 bytes

Size for each variant:

• All: 8 bytes
• Single: 16 bytes