Struct ElaborateDrops

pub(crate) struct ElaborateDrops;

During MIR building, Drop terminators are inserted in every place where a drop may occur. However, in this phase, the presence of these terminators does not guarantee that a destructor will run, as the target of the drop may be uninitialized. In general, the compiler cannot determine at compile time whether a destructor will run or not.

At a high level, this pass refines Drop to only run the destructor if the target is initialized. The way this is achieved is by inserting drop flags for every variable that may be dropped, and then using those flags to determine whether a destructor should run. Once this is complete, Drop terminators in the MIR correspond to a call to the “drop glue” or “drop shim” for the type of the dropped place.

This pass relies on dropped places having an associated move path, which is then used to determine the initialization status of the place and its descendants. It’s worth noting that a MIR containing a Drop without an associated move path is probably ill formed, as it would allow running a destructor on a place behind a reference:

fn drop_term<T>(t: &mut T) {
    mir! {
        {
            Drop(*t, exit)
        }
        exit = {
            Return()
        }
    }
}

Trait Implementations

impl<'tcx> MirPass<'tcx> for ElaborateDrops

fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>)

fn name(&self) -> &'static str

fn profiler_name(&self) -> &'static str

fn is_enabled(&self, _sess: &Session) -> bool

Returns true if this pass is enabled with the current combination of compiler flags.

fn is_mir_dump_enabled(&self) -> bool

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