Enum rustc_middle::ty::BorrowKind

pub enum BorrowKind {
    ImmBorrow,
    UniqueImmBorrow,
    MutBorrow,
}

Variants

ImmBorrow

Data must be immutable and is aliasable.

UniqueImmBorrow

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 mut z = 3;
let x: &mut isize = &mut z;
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<'a> { x: &'a &'a mut isize }
let mut z = 3;
let x: &mut isize = &mut z;
let y = (&mut Env { x: &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<'a> { x: &'a mut &'a mut isize }
let mut z = 3;
let x: &mut isize = &mut z;
let y = (&mut Env { x: &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.

FIXME: Rename this to indicate the borrow is actually not immutable.

MutBorrow

Data is mutable and not aliasable.

Implementations

impl BorrowKind

pub fn from_mutbl(m: Mutability) -> BorrowKind

pub fn to_mutbl_lossy(self) -> Mutability

Returns a mutability m such that an &m T pointer could be used to obtain this borrow kind. Because borrow kinds are richer than mutabilities, we sometimes have to pick a mutability that is stronger than necessary so that it at least would permit the borrow in question.

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 Debug for BorrowKind

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

Formats the value using the given formatter.

impl<'tcx, __D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<__D> for BorrowKind

fn decode(__decoder: &mut __D) -> Self

impl<'tcx, __E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<__E> for BorrowKind

fn encode(&self, __encoder: &mut __E)

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

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

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: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for BorrowKind

fn try_fold_with<__F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, __folder: &mut __F ) -> Result<Self, __F::Error>

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Selfwhere F: TypeFolder<I>,

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.

impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for BorrowKind

fn visit_with<__V: TypeVisitor<TyCtxt<'tcx>>>( &self, __visitor: &mut __V ) -> ControlFlow<__V::BreakTy>

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl Copy for BorrowKind

impl StructuralPartialEq for BorrowKind

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: 1 byte

Size for each variant:

• ImmBorrow: 0 bytes
• UniqueImmBorrow: 0 bytes
• MutBorrow: 0 bytes