Avoid modifying existing blocks.

Author: cjgillot

compiler/rustc_mir_transform/src/elaborate_drop.rs

@@ -277,7 +277,7 @@ where
             (sig.output(), drop_fn_def_id, trait_args)
         };
 
-        let fut = Place::from(self.new_temp(fut_ty));
+        let fut = self.new_temp(fut_ty);
 
         // #1:pin_obj_bb >>> obj_ref = &mut obj
         let obj_ref_ty = Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, drop_ty);
@@ -312,20 +312,34 @@ where
         // causing StorageLive(fut) to fire again without a preceding StorageDead.
         let succ_with_dead = self.new_block_with_statements(
             unwind,
-            vec![Statement::new(self.source_info, StatementKind::StorageDead(fut.local))],
+            vec![self.storage_dead(fut)],
             TerminatorKind::Goto { target: succ },
         );
+        let dropline_with_dead = dropline.map(|target| {
+            self.new_block_with_statements(
+                unwind,
+                vec![self.storage_dead(fut)],
+                TerminatorKind::Goto { target },
+            )
+        });
+        let unwind_with_dead = unwind.map(|target| {
+            self.new_block_with_statements(
+                Unwind::InCleanup,
+                vec![self.storage_dead(fut)],
+                TerminatorKind::Goto { target },
+            )
+        });
 
         // #3:drop_term_bb
         let drop_term_bb = self.new_block(
             unwind,
             TerminatorKind::Drop {
                 place,
                 target: succ_with_dead,
-                unwind: unwind.into_action(),
+                unwind: unwind_with_dead.into_action(),
                 replace: false,
-                drop: dropline,
-                async_fut: Some(fut.local),
+                drop: dropline_with_dead,
+                async_fut: Some(fut),
             },
         );
 
@@ -350,36 +364,21 @@ where
 
             obj_ref_place
         };
-        call_statements
-            .push(Statement::new(self.source_info, StatementKind::StorageLive(fut.local)));
+        call_statements.push(self.storage_live(fut));
 
         let call_drop_bb = self.new_block_with_statements(
             unwind,
             call_statements,
             TerminatorKind::Call {
                 func: Operand::function_handle(tcx, drop_fn_def_id, trait_args, span),
                 args: [Spanned { node: Operand::Move(drop_arg), span: DUMMY_SP }].into(),
-                destination: fut,
+                destination: fut.into(),
                 target: Some(drop_term_bb),
-                unwind: unwind.into_action(),
+                unwind: unwind_with_dead.into_action(),
                 call_source: CallSource::Misc,
                 fn_span: self.source_info.span,
             },
         );
-        // StorageDead(fut) in unwind block (at the begin)
-        if let Unwind::To(block) = unwind {
-            self.elaborator.patch().add_statement(
-                Location { block, statement_index: 0 },
-                StatementKind::StorageDead(fut.local),
-            );
-        }
-        // StorageDead(fut) in dropline block (at the begin)
-        if let Some(block) = dropline {
-            self.elaborator.patch().add_statement(
-                Location { block, statement_index: 0 },
-                StatementKind::StorageDead(fut.local),
-            );
-        }
 
         // #1:pin_obj_bb >>> call Pin<ObjTy>::new_unchecked(&mut obj)
         self.new_block_with_statements(
@@ -1399,4 +1398,12 @@ where
     fn assign(&self, lhs: Place<'tcx>, rhs: Rvalue<'tcx>) -> Statement<'tcx> {
         Statement::new(self.source_info, StatementKind::Assign(Box::new((lhs, rhs))))
     }
+
+    fn storage_live(&self, local: Local) -> Statement<'tcx> {
+        Statement::new(self.source_info, StatementKind::StorageLive(local))
+    }
+
+    fn storage_dead(&self, local: Local) -> Statement<'tcx> {
+        Statement::new(self.source_info, StatementKind::StorageDead(local))
+    }
 }

tests/mir-opt/coroutine/async_drop.core.future-async_drop-async_drop_in_place-{closure#0}.AsyncEnum.MentionedItems.after.mir

@@ -22,17 +22,14 @@ yields ()
 
     bb0: {
         _3 = move (_1.0: &mut AsyncEnum);
-        goto -> bb24;
+        goto -> bb29;
     }
 
     bb1: {
-        StorageDead(_8);
         return;
     }
 
     bb2 (cleanup): {
-        StorageDead(_4);
-        StorageDead(_8);
         resume;
     }
 
@@ -53,90 +50,113 @@ yields ()
         goto -> bb1;
     }
 
-    bb7: {
-        async drop((((*_3) as A).0: AsyncInt); poll=_4) -> [return: bb6, unwind: bb2];
+    bb7 (cleanup): {
+        StorageDead(_4);
+        goto -> bb2;
     }
 
     bb8: {
+        async drop((((*_3) as A).0: AsyncInt); poll=_4) -> [return: bb6, unwind: bb7];
+    }
+
+    bb9: {
         _7 = copy (_6.0: &mut AsyncInt);
         StorageLive(_4);
-        _4 = async_drop_in_place::<AsyncInt>(move _7) -> [return: bb7, unwind: bb2];
+        _4 = async_drop_in_place::<AsyncInt>(move _7) -> [return: bb8, unwind: bb7];
     }
 
-    bb9: {
+    bb10: {
         _5 = &mut (((*_3) as A).0: AsyncInt);
-        _6 = Pin::<&mut AsyncInt>::new_unchecked(move _5) -> [return: bb8, unwind: bb2];
+        _6 = Pin::<&mut AsyncInt>::new_unchecked(move _5) -> [return: bb9, unwind: bb2];
     }
 
-    bb10: {
+    bb11: {
         StorageDead(_8);
         goto -> bb3;
     }
 
-    bb11: {
-        async drop((((*_3) as A).0: AsyncInt); poll=_8) -> [return: bb10, unwind: bb2, drop: bb1];
+    bb12: {
+        StorageDead(_8);
+        goto -> bb1;
     }
 
-    bb12: {
+    bb13 (cleanup): {
+        StorageDead(_8);
+        goto -> bb2;
+    }
+
+    bb14: {
+        async drop((((*_3) as A).0: AsyncInt); poll=_8) -> [return: bb11, unwind: bb13, drop: bb12];
+    }
+
+    bb15: {
         _11 = copy (_10.0: &mut AsyncInt);
         StorageLive(_8);
-        _8 = async_drop_in_place::<AsyncInt>(move _11) -> [return: bb11, unwind: bb2];
+        _8 = async_drop_in_place::<AsyncInt>(move _11) -> [return: bb14, unwind: bb13];
     }
 
-    bb13: {
+    bb16: {
         _9 = &mut (((*_3) as A).0: AsyncInt);
-        _10 = Pin::<&mut AsyncInt>::new_unchecked(move _9) -> [return: bb12, unwind: bb2];
+        _10 = Pin::<&mut AsyncInt>::new_unchecked(move _9) -> [return: bb15, unwind: bb2];
     }
 
-    bb14 (cleanup): {
+    bb17 (cleanup): {
         drop((((*_3) as B).0: SyncInt)) -> [return: bb2, unwind terminate(cleanup)];
     }
 
-    bb15 (cleanup): {
+    bb18 (cleanup): {
         drop((((*_3) as B).0: SyncInt)) -> [return: bb2, unwind terminate(cleanup)];
     }
 
-    bb16: {
+    bb19: {
         drop((((*_3) as B).0: SyncInt)) -> [return: bb1, unwind: bb2];
     }
 
-    bb17: {
+    bb20: {
         drop((((*_3) as B).0: SyncInt)) -> [return: bb3, unwind: bb2];
     }
 
-    bb18: {
+    bb21: {
         _12 = discriminant((*_3));
-        switchInt(move _12) -> [0: bb13, otherwise: bb17];
+        switchInt(move _12) -> [0: bb16, otherwise: bb20];
     }
 
-    bb19 (cleanup): {
-        StorageDead(_15);
+    bb22 (cleanup): {
         _13 = discriminant((*_3));
-        switchInt(move _13) -> [0: bb4, otherwise: bb14];
+        switchInt(move _13) -> [0: bb4, otherwise: bb17];
     }
 
-    bb20: {
-        StorageDead(_15);
+    bb23: {
         _14 = discriminant((*_3));
-        switchInt(move _14) -> [0: bb9, otherwise: bb16];
+        switchInt(move _14) -> [0: bb10, otherwise: bb19];
     }
 
-    bb21: {
+    bb24: {
         StorageDead(_15);
-        goto -> bb18;
+        goto -> bb21;
     }
 
-    bb22: {
-        async drop((*_3); poll=_15) -> [return: bb21, unwind: bb19, drop: bb20];
+    bb25: {
+        StorageDead(_15);
+        goto -> bb23;
     }
 
-    bb23: {
+    bb26 (cleanup): {
+        StorageDead(_15);
+        goto -> bb22;
+    }
+
+    bb27: {
+        async drop((*_3); poll=_15) -> [return: bb24, unwind: bb26, drop: bb25];
+    }
+
+    bb28: {
         StorageLive(_15);
-        _15 = <AsyncEnum as AsyncDrop>::drop(move _17) -> [return: bb22, unwind: bb19];
+        _15 = <AsyncEnum as AsyncDrop>::drop(move _17) -> [return: bb27, unwind: bb26];
     }
 
-    bb24: {
+    bb29: {
         _16 = &mut (*_3);
-        _17 = Pin::<&mut AsyncEnum>::new_unchecked(move _16) -> [return: bb23, unwind: bb19];
+        _17 = Pin::<&mut AsyncEnum>::new_unchecked(move _16) -> [return: bb28, unwind: bb22];
     }
 }