remove is_replace field

Author: zeegomo

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -941,7 +941,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
 
         // drop and replace might have moved the assignment to the next block
         let maybe_additional_statement = if let Some(Terminator {
-            kind: TerminatorKind::Drop { target: drop_target, is_replace: true, .. },
+            kind: TerminatorKind::Drop { target: drop_target, .. },
             ..
         }) = self.body[location.block].terminator
         {

compiler/rustc_borrowck/src/invalidation.rs

@@ -109,7 +109,7 @@ impl<'cx, 'tcx> Visitor<'tcx> for InvalidationGenerator<'cx, 'tcx> {
             TerminatorKind::SwitchInt { discr, targets: _ } => {
                 self.consume_operand(location, discr);
             }
-            TerminatorKind::Drop { place: drop_place, target: _, unwind: _, is_replace: _ } => {
+            TerminatorKind::Drop { place: drop_place, target: _, unwind: _ } => {
                 self.access_place(
                     location,
                     *drop_place,

compiler/rustc_borrowck/src/lib.rs

@@ -578,7 +578,7 @@ impl<'cx, 'tcx> rustc_mir_dataflow::ResultsVisitor<'cx, 'tcx> for MirBorrowckCtx
             StatementKind::Assign(box (lhs, rhs)) => {
                 self.consume_rvalue(location, (rhs, span), flow_state);
 
-                self.mutate_place(location, (*lhs, span), AccessDepth::Shallow(None), flow_state);
+                self.mutate_place(location, (*lhs, span), Shallow(None), flow_state);
             }
             StatementKind::FakeRead(box (_, place)) => {
                 // Read for match doesn't access any memory and is used to
@@ -644,7 +644,7 @@ impl<'cx, 'tcx> rustc_mir_dataflow::ResultsVisitor<'cx, 'tcx> for MirBorrowckCtx
             TerminatorKind::SwitchInt { discr, targets: _ } => {
                 self.consume_operand(loc, (discr, span), flow_state);
             }
-            TerminatorKind::Drop { place, target: _, unwind: _, is_replace: _ } => {
+            TerminatorKind::Drop { place, target: _, unwind: _ } => {
                 debug!(
                     "visit_terminator_drop \
                      loc: {:?} term: {:?} place: {:?} span: {:?}",

compiler/rustc_codegen_cranelift/src/base.rs

@@ -477,7 +477,7 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
             | TerminatorKind::GeneratorDrop => {
                 bug!("shouldn't exist at codegen {:?}", bb_data.terminator());
             }
-            TerminatorKind::Drop { place, target, unwind: _, is_replace: _ } => {
+            TerminatorKind::Drop { place, target, unwind: _ } => {
                 let drop_place = codegen_place(fx, *place);
                 crate::abi::codegen_drop(fx, source_info, drop_place);
 

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -1305,7 +1305,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 MergingSucc::False
             }
 
-            mir::TerminatorKind::Drop { place, target, unwind, is_replace: _ } => {
+            mir::TerminatorKind::Drop { place, target, unwind } => {
                 self.codegen_drop_terminator(helper, bx, place, target, unwind, mergeable_succ())
             }
 

compiler/rustc_const_eval/src/interpret/terminator.rs

@@ -118,7 +118,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 }
             }
 
-            Drop { place, target, unwind, is_replace: _ } => {
+            Drop { place, target, unwind } => {
                 let frame = self.frame();
                 let ty = place.ty(&frame.body.local_decls, *self.tcx).ty;
                 let ty = self.subst_from_frame_and_normalize_erasing_regions(frame, ty)?;

compiler/rustc_middle/src/mir/syntax.rs

@@ -577,14 +577,7 @@ pub enum TerminatorKind<'tcx> {
     /// > The drop glue is executed if, among all statements executed within this `Body`, an assignment to
     /// > the place or one of its "parents" occurred more recently than a move out of it. This does not
     /// > consider indirect assignments.
-    Drop {
-        place: Place<'tcx>,
-        target: BasicBlock,
-        unwind: Option<BasicBlock>,
-        /// This field is only used for better diagnostic and to check MIR drop invariants.
-        /// It has no effect on the semantics of the `Drop` terminator.
-        is_replace: bool,
-    },
+    Drop { place: Place<'tcx>, target: BasicBlock, unwind: Option<BasicBlock> },
 
     /// Roughly speaking, evaluates the `func` operand and the arguments, and starts execution of
     /// the referred to function. The operand types must match the argument types of the function.

compiler/rustc_middle/src/mir/visit.rs

@@ -486,7 +486,6 @@ macro_rules! make_mir_visitor {
                         place,
                         target: _,
                         unwind: _,
-                        is_replace: _,
                     } => {
                         self.visit_place(
                             place,

compiler/rustc_mir_build/src/build/custom/parse/instruction.rs

@@ -47,7 +47,6 @@ impl<'tcx, 'body> ParseCtxt<'tcx, 'body> {
                     place: self.parse_place(args[0])?,
                     target: self.parse_block(args[1])?,
                     unwind: None,
-                    is_replace: false
                 })
             },
             @call("mir_call", args) => {

compiler/rustc_mir_build/src/build/expr/as_rvalue.rs

@@ -624,12 +624,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 this.cfg.terminate(
                     block,
                     outer_source_info,
-                    TerminatorKind::Drop {
-                        place: to_drop,
-                        target: success,
-                        unwind: None,
-                        is_replace: false,
-                    },
+                    TerminatorKind::Drop { place: to_drop, target: success, unwind: None },
                 );
                 this.diverge_from(block);
                 block = success;

compiler/rustc_mir_build/src/build/scope.rs

@@ -371,7 +371,6 @@ impl DropTree {
                         // The caller will handle this if needed.
                         unwind: None,
                         place: drop_data.0.local.into(),
-                        is_replace: false,
                     };
                     cfg.terminate(block, drop_data.0.source_info, terminator);
                 }
@@ -1139,12 +1138,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         self.cfg.terminate(
             block,
             source_info,
-            TerminatorKind::Drop {
-                place,
-                target: next_target,
-                unwind: Some(assign),
-                is_replace: true,
-            },
+            TerminatorKind::Drop { place, target: next_target, unwind: Some(assign) },
         );
 
         self.diverge_from(block);
@@ -1248,12 +1242,7 @@ fn build_scope_drops<'tcx>(
                 cfg.terminate(
                     block,
                     source_info,
-                    TerminatorKind::Drop {
-                        place: local.into(),
-                        target: next,
-                        unwind: None,
-                        is_replace: false,
-                    },
+                    TerminatorKind::Drop { place: local.into(), target: next, unwind: None },
                 );
                 block = next;
             }

compiler/rustc_mir_dataflow/src/elaborate_drops.rs

@@ -164,7 +164,6 @@ where
     path: D::Path,
     succ: BasicBlock,
     unwind: Unwind,
-    is_replace: bool,
 }
 
 /// "Elaborates" a drop of `place`/`path` and patches `bb`'s terminator to execute it.
@@ -183,12 +182,11 @@ pub fn elaborate_drop<'b, 'tcx, D>(
     succ: BasicBlock,
     unwind: Unwind,
     bb: BasicBlock,
-    is_replace: bool,
 ) where
     D: DropElaborator<'b, 'tcx>,
     'tcx: 'b,
 {
-    DropCtxt { elaborator, source_info, place, path, succ, unwind, is_replace }.elaborate_drop(bb)
+    DropCtxt { elaborator, source_info, place, path, succ, unwind }.elaborate_drop(bb)
 }
 
 impl<'l, 'b, 'tcx, D> DropCtxt<'l, 'b, 'tcx, D>
@@ -239,7 +237,6 @@ where
                         place: self.place,
                         target: self.succ,
                         unwind: self.unwind.into_option(),
-                        is_replace: self.is_replace,
                     },
                 );
             }
@@ -301,7 +298,6 @@ where
                 place,
                 succ,
                 unwind,
-                is_replace: self.is_replace,
             }
             .elaborated_drop_block()
         } else {
@@ -316,7 +312,6 @@ where
                 // Using `self.path` here to condition the drop on
                 // our own drop flag.
                 path: self.path,
-                is_replace: self.is_replace,
             }
             .complete_drop(succ, unwind)
         }
@@ -735,7 +730,6 @@ where
                 place: tcx.mk_place_deref(ptr),
                 target: loop_block,
                 unwind: unwind.into_option(),
-                is_replace: self.is_replace,
             },
         );
 
@@ -997,12 +991,8 @@ where
     }
 
     fn drop_block(&mut self, target: BasicBlock, unwind: Unwind) -> BasicBlock {
-        let block = TerminatorKind::Drop {
-            place: self.place,
-            target,
-            unwind: unwind.into_option(),
-            is_replace: self.is_replace,
-        };
+        let block =
+            TerminatorKind::Drop { place: self.place, target, unwind: unwind.into_option() };
         self.new_block(unwind, block)
     }
 

compiler/rustc_mir_transform/src/add_moves_for_packed_drops.rs

@@ -80,7 +80,7 @@ fn add_move_for_packed_drop<'tcx>(
     is_cleanup: bool,
 ) {
     debug!("add_move_for_packed_drop({:?} @ {:?})", terminator, loc);
-    let TerminatorKind::Drop { ref place, target, unwind, is_replace: _ } = terminator.kind else {
+    let TerminatorKind::Drop { ref place, target, unwind } = terminator.kind else {
         unreachable!();
     };
 
@@ -98,11 +98,6 @@ fn add_move_for_packed_drop<'tcx>(
     patch.add_assign(loc, Place::from(temp), Rvalue::Use(Operand::Move(*place)));
     patch.patch_terminator(
         loc.block,
-        TerminatorKind::Drop {
-            place: Place::from(temp),
-            target: storage_dead_block,
-            unwind,
-            is_replace: false,
-        },
+        TerminatorKind::Drop { place: Place::from(temp), target: storage_dead_block, unwind },
     );
 }

compiler/rustc_mir_transform/src/elaborate_drops.rs

@@ -358,7 +358,7 @@ impl<'b, 'tcx> ElaborateDropsCtxt<'b, 'tcx> {
 
             let resume_block = self.patch.resume_block();
             match terminator.kind {
-                TerminatorKind::Drop { mut place, target, unwind, is_replace } => {
+                TerminatorKind::Drop { mut place, target, unwind } => {
                     if let Some(new_place) = self.un_derefer.derefer(place.as_ref(), self.body) {
                         place = new_place;
                     }
@@ -377,17 +377,12 @@ impl<'b, 'tcx> ElaborateDropsCtxt<'b, 'tcx> {
                                 Unwind::To(Option::unwrap_or(unwind, resume_block))
                             },
                             bb,
-                            is_replace,
                         ),
                         LookupResult::Parent(..) => {
-                            if !is_replace {
-                                self.tcx.sess.delay_span_bug(
-                                    terminator.source_info.span,
-                                    &format!("drop of untracked value {:?}", bb),
-                                );
-                            }
                             // drop and replace behind a pointer/array/whatever. The location
                             // must be initialized.
+                            // FIXME: should we check that it's actually the case and we did
+                            // not wrongly emit a drop terminator somewhere / missed move data?
                             Elaborator { ctxt: self }.patch().patch_terminator(
                                 bb,
                                 TerminatorKind::Drop {
@@ -398,7 +393,6 @@ impl<'b, 'tcx> ElaborateDropsCtxt<'b, 'tcx> {
                                     } else {
                                         Some(Option::unwrap_or(unwind, resume_block))
                                     },
-                                    is_replace,
                                 },
                             );
                         }

compiler/rustc_mir_transform/src/generator.rs

@@ -911,14 +911,11 @@ fn elaborate_generator_drops<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
     let mut elaborator = DropShimElaborator { body, patch: MirPatch::new(body), tcx, param_env };
 
     for (block, block_data) in body.basic_blocks.iter_enumerated() {
-        let (target, unwind, source_info, is_replace) = match block_data.terminator() {
-            Terminator {
-                source_info,
-                kind: TerminatorKind::Drop { place, target, unwind, is_replace },
-            } => {
+        let (target, unwind, source_info) = match block_data.terminator() {
+            Terminator { source_info, kind: TerminatorKind::Drop { place, target, unwind } } => {
                 if let Some(local) = place.as_local() {
                     if local == SELF_ARG {
-                        (target, unwind, source_info, is_replace)
+                        (target, unwind, source_info)
                     } else {
                         continue;
                     }
@@ -941,7 +938,6 @@ fn elaborate_generator_drops<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
             *target,
             unwind,
             block,
-            *is_replace,
         );
     }
     elaborator.patch.apply(body);
@@ -1166,12 +1162,8 @@ fn create_generator_resume_function<'tcx>(
 fn insert_clean_drop(body: &mut Body<'_>) -> BasicBlock {
     let return_block = insert_term_block(body, TerminatorKind::Return);
 
-    let term = TerminatorKind::Drop {
-        place: Place::from(SELF_ARG),
-        target: return_block,
-        unwind: None,
-        is_replace: false,
-    };
+    let term =
+        TerminatorKind::Drop { place: Place::from(SELF_ARG), target: return_block, unwind: None };
     let source_info = SourceInfo::outermost(body.span);
 
     // Create a block to destroy an unresumed generators. This can only destroy upvars.

compiler/rustc_mir_transform/src/shim.rs

@@ -218,7 +218,6 @@ fn build_drop_shim<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, ty: Option<Ty<'tcx>>)
                 return_block,
                 elaborate_drops::Unwind::To(resume_block),
                 START_BLOCK,
-                false,
             );
             elaborator.patch
         };
@@ -512,12 +511,7 @@ impl<'tcx> CloneShimBuilder<'tcx> {
             self.make_clone_call(dest_field, src_field, ity, next_block, unwind);
             self.block(
                 vec![],
-                TerminatorKind::Drop {
-                    place: dest_field,
-                    target: unwind,
-                    unwind: None,
-                    is_replace: false,
-                },
+                TerminatorKind::Drop { place: dest_field, target: unwind, unwind: None },
                 true,
             );
             unwind = next_unwind;
@@ -769,12 +763,7 @@ fn build_call_shim<'tcx>(
         block(
             &mut blocks,
             vec![],
-            TerminatorKind::Drop {
-                place: rcvr_place(),
-                target: BasicBlock::new(2),
-                unwind: None,
-                is_replace: false,
-            },
+            TerminatorKind::Drop { place: rcvr_place(), target: BasicBlock::new(2), unwind: None },
             false,
         );
     }
@@ -785,12 +774,7 @@ fn build_call_shim<'tcx>(
         block(
             &mut blocks,
             vec![],
-            TerminatorKind::Drop {
-                place: rcvr_place(),
-                target: BasicBlock::new(4),
-                unwind: None,
-                is_replace: false,
-            },
+            TerminatorKind::Drop { place: rcvr_place(), target: BasicBlock::new(4), unwind: None },
             true,
         );