Enum rustc_middle::mir::BorrowKind

pub enum BorrowKind {
    Shared,
    Shallow,
    Unique,
    Mut {
        allow_two_phase_borrow: bool,
    },
}

Variants

Shared

Data must be immutable and is aliasable.

Shallow

The immediately borrowed place must be immutable, but projections from it don't need to be. For example, a shallow borrow of a.b doesn't conflict with a mutable borrow of a.b.c.

This is used when lowering matches: when matching on a place we want to ensure that place have the same value from the start of the match until an arm is selected. This prevents this code from compiling:

let mut x = &Some(0);
match *x {
    None => (),
    Some(_) if { x = &None; false } => (),
    Some(_) => (),
}

This can't be a shared borrow because mutably borrowing (*x as Some).0 should not prevent if let None = x { ... }, for example, because the mutating (*x as Some).0 can't affect the discriminant of x. We can also report errors with this kind of borrow differently.

Unique

Data must be immutable but not aliasable. This kind of borrow cannot currently be expressed by the user and is used only in implicit closure bindings. It is needed when the closure is borrowing or mutating a mutable referent, e.g.:

let x: &mut isize = ...;
let y = || *x += 5;

If we were to try to translate this closure into a more explicit form, we'd encounter an error with the code as written:

struct Env { x: & &mut isize }
let x: &mut isize = ...;
let y = (&mut Env { &x }, fn_ptr);  // Closure is pair of env and fn
fn fn_ptr(env: &mut Env) { **env.x += 5; }

This is then illegal because you cannot mutate an &mut found in an aliasable location. To solve, you'd have to translate with an &mut borrow:

struct Env { x: & &mut isize }
let x: &mut isize = ...;
let y = (&mut Env { &mut x }, fn_ptr); // changed from &x to &mut x
fn fn_ptr(env: &mut Env) { **env.x += 5; }

Now the assignment to **env.x is legal, but creating a mutable pointer to x is not because x is not mutable. We could fix this by declaring x as let mut x. This is ok in user code, if awkward, but extra weird for closures, since the borrow is hidden.

So we introduce a "unique imm" borrow -- the referent is immutable, but not aliasable. This solves the problem. For simplicity, we don't give users the way to express this borrow, it's just used when translating closures.

Mut

Data is mutable and not aliasable.

Fields of Mut

allow_two_phase_borrow: bool

true if this borrow arose from method-call auto-ref (i.e., adjustment::Adjust::Borrow).

Implementations

impl BorrowKind

pub fn to_mutbl_lossy(self) -> Mutability

impl BorrowKind

pub fn allows_two_phase_borrow(&self) -> bool

Trait Implementations

impl Clone for BorrowKind

fn clone(&self) -> BorrowKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for BorrowKind

impl Debug for BorrowKind

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

Formats the value using the given formatter.

impl Decodable for BorrowKind

fn decode<__D: Decoder>(d: &mut __D) -> Result<BorrowKind, __D::Error>

impl Encodable for BorrowKind

fn encode<__S: Encoder>(&self, s: &mut __S) -> Result<(), __S::Error>

impl Eq for BorrowKind

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for BorrowKind

fn hash_stable(
    &self,
    __hcx: &mut StableHashingContext<'__ctx>,
    __hasher: &mut StableHasher
)

impl Ord for BorrowKind

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

This method returns an [Ordering] between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

#[must_use]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<BorrowKind> for BorrowKind

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

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

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

This method tests for !=.

impl PartialOrd<BorrowKind> for BorrowKind

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

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

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

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

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

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

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

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

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

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

impl StructuralEq for BorrowKind

impl StructuralPartialEq for BorrowKind