Enum rustc::mir::repr::BorrowKind

pub enum BorrowKind {
    Shared,
    Unique,
    Mut,
}

Unstable (rustc_private)

Variants

Shared

Unstable (rustc_private)

Data must be immutable and is aliasable.

Unique

Unstable (rustc_private)

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 you 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 a &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

Unstable (rustc_private)

Data is mutable and not aliasable.

Methods

impl BorrowKind

fn to_mutbl_lossy(self) -> Mutability

Trait Implementations

Derived Implementations

impl Decodable for BorrowKind

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

impl Encodable for BorrowKind

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

impl Eq for BorrowKind

impl PartialEq for BorrowKind

fn eq(&self, __arg_0: &BorrowKind) -> 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 Debug for BorrowKind

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

Formats the value using the given formatter.

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