Enum FakeReadCause

pub enum FakeReadCause {
    ForMatchGuard,
    ForMatchedPlace(Option<LocalDefId>),
    ForGuardBinding,
    ForLet(Option<LocalDefId>),
    ForIndex,
}

The FakeReadCause describes the type of pattern why a FakeRead statement exists.

Variants

ForMatchGuard

A fake read injected into a match guard to ensure that the discriminants that are being matched on aren’t modified while the match guard is being evaluated.

At the beginning of each match guard, a fake borrow is inserted for each discriminant accessed in the entire match statement.

Then, at the end of the match guard, a FakeRead(ForMatchGuard) is inserted to keep the fake borrows alive until that point.

This should ensure that you cannot change the variant for an enum while you are in the midst of matching on it.

ForMatchedPlace(Option<LocalDefId>)

Fake read of the scrutinee of a match or destructuring let (i.e. let with non-trivial pattern).

In match x { ... }, we generate a FakeRead(ForMatchedPlace, x) and insert it into the otherwise_block (which is supposed to be unreachable for irrefutable pattern-matches like match or let).

This is necessary because let x: !; match x {} doesn’t generate any actual read of x, so we need to generate a FakeRead to check that it is initialized.

If the FakeRead(ForMatchedPlace) is being performed with a closure that doesn’t capture the required upvars, the FakeRead within the closure is omitted entirely.

To make sure that this is still sound, if a closure matches against a Place starting with an Upvar, we hoist the FakeRead to the definition point of the closure.

If the FakeRead comes from being hoisted out of a closure like this, we record the LocalDefId of the closure. Otherwise, the Option will be None.

ForGuardBinding

A fake read injected into a match guard to ensure that the places bound by the pattern are immutable for the duration of the match guard.

Within a match guard, references are created for each place that the pattern creates a binding for — this is known as the RefWithinGuard version of the variables. To make sure that the references stay alive until the end of the match guard, and properly prevent the places in question from being modified, a FakeRead(ForGuardBinding) is inserted at the end of the match guard.

For details on how these references are created, see the extensive documentation on bind_matched_candidate_for_guard in rustc_mir_build.

ForLet(Option<LocalDefId>)

Officially, the semantics of

let pattern = <expr>;

is that <expr> is evaluated into a temporary and then this temporary is into the pattern.

However, if we see the simple pattern let var = <expr>, we optimize this to evaluate <expr> directly into the variable var. This is mostly unobservable, but in some cases it can affect the borrow checker, as in #53695.

Therefore, we insert a FakeRead(ForLet) immediately after each let with a trivial pattern.

FIXME: ExprUseVisitor has an entirely different opinion on what FakeRead(ForLet) is supposed to mean. If it was accurate to what MIR lowering does, would it even make sense to hoist these out of closures like ForMatchedPlace?

ForIndex

Currently, index expressions overloaded through the Index trait get lowered differently than index expressions with builtin semantics for arrays and slices — the latter will emit code to perform bound checks, and then return a MIR place that will only perform the indexing “for real” when it gets incorporated into an instruction.

This is observable in the fact that the following compiles:

fn f(x: &mut [&mut [u32]], i: usize) {
    x[i][x[i].len() - 1] += 1;
}

However, we need to be careful to not let the user invalidate the bound check with an expression like

(*x)[1][{ x = y; 4}]

Here, the first bounds check would be invalidated when we evaluate the second index expression. To make sure that this doesn’t happen, we create a fake borrow of x and hold it while we evaluate the second index.

This borrow is kept alive by a FakeRead(ForIndex) at the end of its scope.

Trait Implementations

impl Clone for FakeReadCause

fn clone(&self) -> FakeReadCause

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for FakeReadCause

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

Formats the value using the given formatter.

impl<'tcx, __D: TyDecoder<'tcx>> Decodable<__D> for FakeReadCause

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

impl<'tcx, __E: TyEncoder<'tcx>> Encodable<__E> for FakeReadCause

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

impl Hash for FakeReadCause

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<'__ctx> HashStable<StableHashingContext<'__ctx>> for FakeReadCause

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

impl PartialEq for FakeReadCause

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

Tests for self and other values to be equal, and is used by ==.

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

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

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

fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, _: &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: TypeFolder<TyCtxt<'tcx>>>(self, _: &mut F) -> Self

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

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

fn visit_with<F: TypeVisitor<TyCtxt<'tcx>>>(&self, _: &mut F) -> F::Result

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

impl Copy for FakeReadCause

impl StructuralPartialEq for FakeReadCause

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: 8 bytes

Size for each variant:

• ForMatchGuard: 0 bytes
• ForMatchedPlace: 4 bytes
• ForGuardBinding: 0 bytes
• ForLet: 4 bytes
• ForIndex: 0 bytes