[][src]Enum rustc_middle::mir::BorrowKind

pub enum BorrowKind {
    Mut {
        allow_two_phase_borrow: bool,



Data must be immutable and is aliasable.


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.


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.


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).


impl BorrowKind[src]

pub fn to_mutbl_lossy(self) -> Mutability[src]

impl BorrowKind[src]

pub fn allows_two_phase_borrow(&self) -> bool[src]

Trait Implementations

impl Clone for BorrowKind[src]

impl Copy for BorrowKind[src]

impl Debug for BorrowKind[src]

impl Decodable for BorrowKind[src]

impl Encodable for BorrowKind[src]

impl Eq for BorrowKind[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for BorrowKind[src]

impl Ord for BorrowKind[src]

impl PartialEq<BorrowKind> for BorrowKind[src]

impl PartialOrd<BorrowKind> for BorrowKind[src]

impl StructuralEq for BorrowKind[src]

impl StructuralPartialEq for BorrowKind[src]

Auto Trait Implementations

impl RefUnwindSafe for BorrowKind

impl Send for BorrowKind

impl Sync for BorrowKind

impl Unpin for BorrowKind

impl UnwindSafe for BorrowKind

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized

impl<'tcx, T> ArenaAllocatable<'tcx, ()> for T where
    T: Copy

impl<T> Borrow<T> for T where
    T: ?Sized

impl<T> BorrowMut<T> for T where
    T: ?Sized

impl<'a, T> Captures<'a> for T where
    T: ?Sized

impl<T> Decodable for T where
    T: UseSpecializedDecodable

impl<Ctxt, T> DepNodeParams<Ctxt> for T where
    Ctxt: DepContext,
    T: HashStable<<Ctxt as DepContext>::StableHashingContext> + Debug

impl<T> Encodable for T where
    T: UseSpecializedEncodable + ?Sized

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 

impl<T> MaybeResult<T> for T[src]

type Error = !

impl<T> ToOwned for T where
    T: Clone

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> WithConstness for T[src]