Struct rustc_mir_build::build::scope::DropTree

struct DropTree {
    drops: IndexVec<DropIdx, (DropData, DropIdx)>,
    previous_drops: FxHashMap<(DropIdx, Local, DropKind), DropIdx>,
    entry_points: Vec<(DropIdx, BasicBlock)>,
}

A tree of drops that we have deferred lowering. It’s used for:

• Drops on unwind paths
• Drops on generator drop paths (when a suspended generator is dropped)
• Drops on return and loop exit paths
• Drops on the else path in an if let chain

Once no more nodes could be added to the tree, we lower it to MIR in one go in build_mir.

Fields

drops: IndexVec<DropIdx, (DropData, DropIdx)>

Drops in the tree.

previous_drops: FxHashMap<(DropIdx, Local, DropKind), DropIdx>

Map for finding the inverse of the next_drop relation:

previous_drops[(drops[i].1, drops[i].0.local, drops[i].0.kind)] == i

entry_points: Vec<(DropIdx, BasicBlock)>

Edges into the DropTree that need to be added once it’s lowered.

Implementations

impl DropTree

fn new() -> Self

fn add_drop(&mut self, drop: DropData, next: DropIdx) -> DropIdx

fn add_entry(&mut self, from: BasicBlock, to: DropIdx)

fn build_mir<'tcx, T: DropTreeBuilder<'tcx>>(
    &mut self,
    cfg: &mut CFG<'tcx>,
    blocks: &mut IndexVec<DropIdx, Option<BasicBlock>>
)

Builds the MIR for a given drop tree.

blocks should have the same length as self.drops, and may have its first value set to some already existing block.

fn assign_blocks<'tcx, T: DropTreeBuilder<'tcx>>(
    &mut self,
    cfg: &mut CFG<'tcx>,
    blocks: &mut IndexVec<DropIdx, Option<BasicBlock>>
)

Assign blocks for all of the drops in the drop tree that need them.

fn link_blocks<'tcx>(
    &self,
    cfg: &mut CFG<'tcx>,
    blocks: &IndexVec<DropIdx, Option<BasicBlock>>
)

Trait Implementations

impl Debug for DropTree

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

Formats the value using the given formatter.

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