Struct DropTree

struct DropTree {
    drops: IndexVec<DropIdx, DropNode>,
    existing_drops_map: FxHashMap<DropNodeKey, 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 coroutine drop paths (when a suspended coroutine 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, DropNode>

Nodes in the drop tree, containing drop data and a link to the next node.

existing_drops_map: FxHashMap<DropNodeKey, DropIdx>

Map for finding the index of an existing node, given its contents.

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, data: DropData, next: DropIdx) -> DropIdx

Adds a node to the drop tree, consisting of drop data and the index of the “next” drop (in drop order), which could be the sentinel ROOT_NODE.

If there is already an equivalent node in the tree, nothing is added, and that node’s index is returned. Otherwise, the new node’s index is returned.

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

Registers from as an entry point to this drop tree, at to.

During Self::build_mir, from will be linked to the corresponding block within the drop tree.

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: &IndexSlice<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