fn open_drop<'a>(&mut self) -> BasicBlock {
        let ty = self.lvalue_ty(self.lvalue);
        let is_cleanup = self.is_cleanup; // FIXME(#6393)
        let succ = self.succ;
        match ty.sty {
            ty::TyClosure(def_id, substs) => {
                let tys : Vec<_> = substs.upvar_tys(def_id, self.tcx()).collect();
                self.open_drop_for_tuple(&tys)
            }
            ty::TyTuple(tys, _) => {
                self.open_drop_for_tuple(tys)
            }
            ty::TyAdt(def, _) if def.is_box() => {
                self.open_drop_for_box(ty.boxed_ty())
            }
            ty::TyAdt(def, substs) => {
                self.open_drop_for_adt(def, substs)
            }
            ty::TyDynamic(..) => {
                self.complete_drop(is_cleanup, Some(DropFlagMode::Deep), succ)
            }
            ty::TyArray(..) | ty::TySlice(..) => {
                // FIXME(#34708): handle partially-dropped
                // array/slice elements.
                self.complete_drop(is_cleanup, Some(DropFlagMode::Deep), succ)
            }
            _ => bug!("open drop from non-ADT `{:?}`", ty)
        }
    }
/// The slow-path - create an "open", elaborated drop for a type
/// which is moved-out-of only partially, and patch `bb` to a jump
/// to it. This must not be called on ADTs with a destructor,
/// as these can't be moved-out-of, except for `Box<T>`, which is
/// special-cased.
///
/// This creates a "drop ladder" that drops the needed fields of the
/// ADT, both in the success case or if one of the destructors fail.
The slow-path - create an "open", elaborated drop for a type
which is moved-out-of only partially, and patch `bb` to a jump
to it. This must not be called on ADTs with a destructor,
as these can't be moved-out-of, except for `Box`, which is
special-cased.

This creates a "drop ladder" that drops the needed fields of the
ADT, both in the success case or if one of the destructors fail.
The slow - path - create an " open " elaborated drop for a type which is moved - out - of only partially and patch ` bb ` to a jump to it . This must not be called on ADTs with a destructor as these can ' t be moved - out - of except for ` Box ` which is special - cased . This creates a " drop ladder " that drops the needed fields of the ADT both in the success case or if one of the destructors fail .
fn open_drop<'a>(&mut self) -> BasicBlock {
        let ty = self.lvalue_ty(self.lvalue);
        let is_cleanup = self.is_cleanup; // FIXME(#6393)
        let succ = self.succ;
        match ty.sty {
            ty::TyClosure(def_id, substs) => {
                let tys : Vec<_> = substs.upvar_tys(def_id, self.tcx()).collect();
                self.open_drop_for_tuple(&tys)
            }
            ty::TyTuple(tys, _) => {
                self.open_drop_for_tuple(tys)
            }
            ty::TyAdt(def, _) if def.is_box() => {
                self.open_drop_for_box(ty.boxed_ty())
            }
            ty::TyAdt(def, substs) => {
                self.open_drop_for_adt(def, substs)
            }
            ty::TyDynamic(..) => {
                self.complete_drop(is_cleanup, Some(DropFlagMode::Deep), succ)
            }
            ty::TyArray(..) | ty::TySlice(..) => {
                // FIXME(#34708): handle partially-dropped
                // array/slice elements.
                self.complete_drop(is_cleanup, Some(DropFlagMode::Deep), succ)
            }
            _ => bug!("open drop from non-ADT `{:?}`", ty)
        }
    }
fn open_drop < ' a > ( & mut self ) -> BasicBlock { let ty = self . lvalue_ty ( self . lvalue ) ; let is_cleanup = self . is_cleanup ; // FIXME(#6393) let succ = self . succ ; match ty . sty { ty :: TyClosure ( def_id , substs ) => { let tys : Vec < _ > = substs . upvar_tys ( def_id , self . tcx ( ) ) . collect ( ) ; self . open_drop_for_tuple ( & tys ) } ty :: TyTuple ( tys , _ ) => { self . open_drop_for_tuple ( tys ) } ty :: TyAdt ( def , _ ) if def . is_box ( ) => { self . open_drop_for_box ( ty . boxed_ty ( ) ) } ty :: TyAdt ( def , substs ) => { self . open_drop_for_adt ( def , substs ) } ty :: TyDynamic ( .. ) => { self . complete_drop ( is_cleanup , Some ( DropFlagMode :: Deep ) , succ ) } ty :: TyArray ( .. ) | ty :: TySlice ( .. ) => { // FIXME(#34708): handle partially-dropped // array/slice elements. self . complete_drop ( is_cleanup , Some ( DropFlagMode :: Deep ) , succ ) } _ => bug ! ( " " ty ) } }
The slow-path - create an "open", elaborated drop for a type
which is moved-out-of only partially, and patch `bb` to a jump
to it.
The slow - path - create an " open " elaborated drop for a type which is moved - out - of only partially and patch ` bb ` to a jump to it .
&mut self
&mut self