Struct rustc_mir_dataflow::impls::borrowed_locals::MaybeBorrowedLocals

pub struct MaybeBorrowedLocals<K = AnyBorrow> {
    kind: K,
    ignore_borrow_on_drop: bool,
}

A dataflow analysis that tracks whether a pointer or reference could possibly exist that points to a given local.

The K parameter determines what kind of borrows are tracked. By default, MaybeBorrowedLocals looks for any borrow of a local. If you are only interested in borrows that might allow mutation, use the MaybeMutBorrowedLocals type alias instead.

At present, this is used as a very limited form of alias analysis. For example, MaybeBorrowedLocals is used to compute which locals are live during a yield expression for immovable generators. MaybeMutBorrowedLocals is used during const checking to prove that a local has not been mutated via indirect assignment (e.g., *p = 42), the side-effects of a function call or inline assembly.

Fields

kind: K

ignore_borrow_on_drop: bool

Implementations

impl MaybeBorrowedLocals

pub fn all_borrows() -> Self

A dataflow analysis that records whether a pointer or reference exists that may alias the given local.

impl<'mir, 'tcx> MaybeBorrowedLocals<MutBorrow<'mir, 'tcx>>

pub fn mut_borrows_only(
    tcx: TyCtxt<'tcx>,
    body: &'mir Body<'tcx>,
    param_env: ParamEnv<'tcx>
) -> Self

A dataflow analysis that records whether a pointer or reference exists that may mutably alias the given local.

This includes &mut and pointers derived from an &mut, as well as shared borrows of types with interior mutability.

impl<K> MaybeBorrowedLocals<K>

pub fn unsound_ignore_borrow_on_drop(self) -> Self

During dataflow analysis, ignore the borrow that may occur when a place is dropped.

Drop terminators may call custom drop glue (Drop::drop), which takes &mut self as a parameter. In the general case, a drop impl could launder that reference into the surrounding environment through a raw pointer, thus creating a valid *mut pointing to the dropped local. We are not yet willing to declare this particular case UB, so we must treat all dropped locals as mutably borrowed for now. See discussion on #61069.

In some contexts, we know that this borrow will never occur. For example, during const-eval, custom drop glue cannot be run. Code that calls this should document the assumptions that justify ignoring Drop terminators in this way.

fn transfer_function<'a, T>(
    &'a self,
    trans: &'a mut T
) -> TransferFunction<'a, T, K>

Trait Implementations

impl<K, 'tcx> AnalysisDomain<'tcx> for MaybeBorrowedLocals<K> where
    K: BorrowAnalysisKind<'tcx>, 

type Domain = BitSet<Local>

The type that holds the dataflow state at any given point in the program.

const NAME: &'static str

A descriptive name for this analysis. Used only for debugging.

fn bottom_value(&self, body: &Body<'tcx>) -> Self::Domain

The initial value of the dataflow state upon entry to each basic block.

fn initialize_start_block(&self, _: &Body<'tcx>, _: &mut Self::Domain)

Mutates the initial value of the dataflow state upon entry to the START_BLOCK.

type Direction: Direction = Forward

The direction of this analysis. Either Forward or Backward.

impl<K, 'tcx> GenKillAnalysis<'tcx> for MaybeBorrowedLocals<K> where
    K: BorrowAnalysisKind<'tcx>, 

type Idx = Local

fn statement_effect(
    &self,
    trans: &mut impl GenKill<Self::Idx>,
    statement: &Statement<'tcx>,
    location: Location
)

See Analysis::apply_statement_effect.

fn terminator_effect(
    &self,
    trans: &mut impl GenKill<Self::Idx>,
    terminator: &Terminator<'tcx>,
    location: Location
)

See Analysis::apply_terminator_effect.

fn call_return_effect(
    &self,
    _trans: &mut impl GenKill<Self::Idx>,
    _block: BasicBlock,
    _func: &Operand<'tcx>,
    _args: &[Operand<'tcx>],
    _dest_place: Place<'tcx>
)

See Analysis::apply_call_return_effect.

fn before_statement_effect(
    &self,
    _trans: &mut impl GenKill<Self::Idx>,
    _statement: &Statement<'tcx>,
    _location: Location
)

See Analysis::apply_before_statement_effect.

fn before_terminator_effect(
    &self,
    _trans: &mut impl GenKill<Self::Idx>,
    _terminator: &Terminator<'tcx>,
    _location: Location
)

See Analysis::apply_before_terminator_effect.

fn yield_resume_effect(
    &self,
    _trans: &mut impl GenKill<Self::Idx>,
    _resume_block: BasicBlock,
    _resume_place: Place<'tcx>
)

See Analysis::apply_yield_resume_effect.

fn switch_int_edge_effects<G: GenKill<Self::Idx>>(
    &self,
    _block: BasicBlock,
    _discr: &Operand<'tcx>,
    _edge_effects: &mut impl SwitchIntEdgeEffects<G>
)

See Analysis::apply_switch_int_edge_effects.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.