Drop if

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -2200,10 +2200,10 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                         ProjectionElem::Deref => match kind {
                             StorageDeadOrDrop::LocalStorageDead
                             | StorageDeadOrDrop::BoxedStorageDead => {
-                                assert!(
-                                    place_ty.ty.is_box(),
-                                    "Drop of value behind a reference or raw pointer"
-                                );
+                                // assert!(
+                                //     place_ty.ty.is_box(),
+                                //     "Drop of value behind a reference or raw pointer"
+                                // );
                                 StorageDeadOrDrop::BoxedStorageDead
                             }
                             StorageDeadOrDrop::Destructor(_) => kind,

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -937,7 +937,22 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
             return OtherUse(use_span);
         }
 
-        for stmt in &self.body[location.block].statements[location.statement_index + 1..] {
+        // drop and replace might have moved the assignment to the next block
+        let maybe_additional_statement = if let Some(Terminator {
+            kind: TerminatorKind::DropIfInit { target: drop_target, is_replace: true, .. },
+            ..
+        }) = self.body[location.block].terminator
+        {
+            self.body[drop_target].statements.iter().take(1)
+        } else {
+            [].iter().take(0)
+        };
+
+        let statements = self.body[location.block].statements[location.statement_index + 1..]
+            .iter()
+            .chain(maybe_additional_statement);
+
+        for stmt in statements {
             if let StatementKind::Assign(box (_, Rvalue::Aggregate(ref kind, ref places))) =
                 stmt.kind
             {

compiler/rustc_borrowck/src/invalidation.rs

@@ -10,8 +10,8 @@ use rustc_middle::ty::TyCtxt;
 
 use crate::{
     borrow_set::BorrowSet, facts::AllFacts, location::LocationTable, path_utils::*, AccessDepth,
-    Activation, ArtificialField, BorrowIndex, Deep, LocalMutationIsAllowed, Read, ReadKind,
-    ReadOrWrite, Reservation, Shallow, Write, WriteKind,
+    Activation, ArtificialField, BorrowIndex, Deep, FxHashSet, LocalMutationIsAllowed, Read,
+    ReadKind, ReadOrWrite, Reservation, Shallow, Write, WriteKind,
 };
 
 pub(super) fn generate_invalidates<'tcx>(
@@ -36,6 +36,7 @@ pub(super) fn generate_invalidates<'tcx>(
             location_table,
             body: &body,
             dominators,
+            to_skip: Default::default(),
         };
         ig.visit_body(body);
     }
@@ -48,6 +49,7 @@ struct InvalidationGenerator<'cx, 'tcx> {
     body: &'cx Body<'tcx>,
     dominators: Dominators<BasicBlock>,
     borrow_set: &'cx BorrowSet<'tcx>,
+    to_skip: FxHashSet<Location>,
 }
 
 /// Visits the whole MIR and generates `invalidates()` facts.
@@ -59,8 +61,9 @@ impl<'cx, 'tcx> Visitor<'tcx> for InvalidationGenerator<'cx, 'tcx> {
         match &statement.kind {
             StatementKind::Assign(box (lhs, rhs)) => {
                 self.consume_rvalue(location, rhs);
-
-                self.mutate_place(location, *lhs, Shallow(None));
+                if !self.to_skip.contains(&location) {
+                    self.mutate_place(location, *lhs, Shallow(None));
+                }
             }
             StatementKind::FakeRead(box (_, _)) => {
                 // Only relevant for initialized/liveness/safety checks.
@@ -109,22 +112,37 @@ impl<'cx, 'tcx> Visitor<'tcx> for InvalidationGenerator<'cx, 'tcx> {
             TerminatorKind::SwitchInt { ref discr, switch_ty: _, targets: _ } => {
                 self.consume_operand(location, discr);
             }
-            TerminatorKind::Drop { place: drop_place, target: _, unwind: _ } => {
-                self.access_place(
-                    location,
-                    *drop_place,
-                    (AccessDepth::Drop, Write(WriteKind::StorageDeadOrDrop)),
-                    LocalMutationIsAllowed::Yes,
-                );
-            }
-            TerminatorKind::DropAndReplace {
-                place: drop_place,
-                value: ref new_value,
-                target: _,
-                unwind: _,
-            } => {
-                self.mutate_place(location, *drop_place, Deep);
-                self.consume_operand(location, new_value);
+            TerminatorKind::DropIfInit { place: drop_place, target, unwind, is_replace }
+            | TerminatorKind::DropIf { place: drop_place, target, unwind, is_replace, test: _ } => {
+                let next_statement = if *is_replace {
+                    self.body
+                        .basic_blocks
+                        .get(*target)
+                        .expect("MIR should be complete at this point")
+                        .statements
+                        .first()
+                } else {
+                    None
+                };
+
+                match next_statement {
+                    Some(Statement { kind: StatementKind::Assign(_), source_info: _ }) => {
+                        // this is a drop from a replace operation, for better diagnostic report
+                        // here possible conflicts and mute the assign statement errors
+                        self.to_skip.insert(Location { block: *target, statement_index: 0 });
+                        self.to_skip
+                            .insert(Location { block: unwind.unwrap(), statement_index: 0 });
+                        self.mutate_place(location, *drop_place, AccessDepth::Deep);
+                    }
+                    _ => {
+                        self.access_place(
+                            location,
+                            *drop_place,
+                            (AccessDepth::Drop, Write(WriteKind::StorageDeadOrDrop)),
+                            LocalMutationIsAllowed::Yes,
+                        );
+                    }
+                }
             }
             TerminatorKind::Call {
                 ref func,

compiler/rustc_borrowck/src/lib.rs

@@ -343,6 +343,7 @@ fn do_mir_borrowck<'tcx>(
                 next_region_name: RefCell::new(1),
                 polonius_output: None,
                 errors,
+                to_skip: Default::default(),
             };
             promoted_mbcx.report_move_errors(move_errors);
             errors = promoted_mbcx.errors;
@@ -374,6 +375,7 @@ fn do_mir_borrowck<'tcx>(
         next_region_name: RefCell::new(1),
         polonius_output,
         errors,
+        to_skip: Default::default(),
     };
 
     // Compute and report region errors, if any.
@@ -556,6 +558,8 @@ struct MirBorrowckCtxt<'cx, 'tcx> {
     polonius_output: Option<Rc<PoloniusOutput>>,
 
     errors: error::BorrowckErrors<'tcx>,
+
+    to_skip: FxHashSet<Location>,
 }
 
 // Check that:
@@ -580,8 +584,9 @@ impl<'cx, 'tcx> rustc_mir_dataflow::ResultsVisitor<'cx, 'tcx> for MirBorrowckCtx
         match &stmt.kind {
             StatementKind::Assign(box (lhs, ref rhs)) => {
                 self.consume_rvalue(location, (rhs, span), flow_state);
-
-                self.mutate_place(location, (*lhs, span), Shallow(None), flow_state);
+                if !self.to_skip.contains(&location) {
+                    self.mutate_place(location, (*lhs, span), Shallow(None), flow_state);
+                }
             }
             StatementKind::FakeRead(box (_, ref place)) => {
                 // Read for match doesn't access any memory and is used to
@@ -647,29 +652,44 @@ impl<'cx, 'tcx> rustc_mir_dataflow::ResultsVisitor<'cx, 'tcx> for MirBorrowckCtx
             TerminatorKind::SwitchInt { ref discr, switch_ty: _, targets: _ } => {
                 self.consume_operand(loc, (discr, span), flow_state);
             }
-            TerminatorKind::Drop { place, target: _, unwind: _ } => {
+            TerminatorKind::DropIfInit { place, target, unwind, is_replace }
+            | TerminatorKind::DropIf { place, target, unwind, is_replace, test: _ } => {
                 debug!(
                     "visit_terminator_drop \
                      loc: {:?} term: {:?} place: {:?} span: {:?}",
                     loc, term, place, span
                 );
 
-                self.access_place(
-                    loc,
-                    (place, span),
-                    (AccessDepth::Drop, Write(WriteKind::StorageDeadOrDrop)),
-                    LocalMutationIsAllowed::Yes,
-                    flow_state,
-                );
-            }
-            TerminatorKind::DropAndReplace {
-                place: drop_place,
-                value: ref new_value,
-                target: _,
-                unwind: _,
-            } => {
-                self.mutate_place(loc, (drop_place, span), Deep, flow_state);
-                self.consume_operand(loc, (new_value, span), flow_state);
+                let next_statement = if is_replace {
+                    self.body()
+                        .basic_blocks
+                        .get(target)
+                        .expect("MIR should be complete at this point")
+                        .statements
+                        .first()
+                } else {
+                    None
+                };
+
+                match next_statement {
+                    Some(Statement { kind: StatementKind::Assign(_), source_info: _ }) => {
+                        // this is a drop from a replace operation, for better diagnostic report
+                        // here possible conflicts and mute the assign statement errors
+                        self.to_skip.insert(Location { block: target, statement_index: 0 });
+                        self.to_skip
+                            .insert(Location { block: unwind.unwrap(), statement_index: 0 });
+                        self.mutate_place(loc, (place, span), AccessDepth::Deep, flow_state);
+                    }
+                    _ => {
+                        self.access_place(
+                            loc,
+                            (place, span),
+                            (AccessDepth::Drop, Write(WriteKind::StorageDeadOrDrop)),
+                            LocalMutationIsAllowed::Yes,
+                            flow_state,
+                        );
+                    }
+                }
             }
             TerminatorKind::Call {
                 ref func,
@@ -784,8 +804,8 @@ impl<'cx, 'tcx> rustc_mir_dataflow::ResultsVisitor<'cx, 'tcx> for MirBorrowckCtx
             TerminatorKind::Abort
             | TerminatorKind::Assert { .. }
             | TerminatorKind::Call { .. }
-            | TerminatorKind::Drop { .. }
-            | TerminatorKind::DropAndReplace { .. }
+            | TerminatorKind::DropIfInit { .. }
+            | TerminatorKind::DropIf { .. }
             | TerminatorKind::FalseEdge { real_target: _, imaginary_target: _ }
             | TerminatorKind::FalseUnwind { real_target: _, unwind: _ }
             | TerminatorKind::Goto { .. }
@@ -1627,7 +1647,8 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                 (prefix, place_span.0, place_span.1),
                 mpi,
             );
-        } // Only query longest prefix with a MovePath, not further
+        }
+        // Only query longest prefix with a MovePath, not further
         // ancestors; dataflow recurs on children when parents
         // move (to support partial (re)inits).
         //

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1342,31 +1342,13 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             | TerminatorKind::Return
             | TerminatorKind::GeneratorDrop
             | TerminatorKind::Unreachable
-            | TerminatorKind::Drop { .. }
+            | TerminatorKind::DropIfInit { .. }
+            | TerminatorKind::DropIf { .. }
             | TerminatorKind::FalseEdge { .. }
             | TerminatorKind::FalseUnwind { .. }
             | TerminatorKind::InlineAsm { .. } => {
                 // no checks needed for these
             }
-
-            TerminatorKind::DropAndReplace { ref place, ref value, target: _, unwind: _ } => {
-                let place_ty = place.ty(body, tcx).ty;
-                let rv_ty = value.ty(body, tcx);
-
-                let locations = term_location.to_locations();
-                if let Err(terr) =
-                    self.sub_types(rv_ty, place_ty, locations, ConstraintCategory::Assignment)
-                {
-                    span_mirbug!(
-                        self,
-                        term,
-                        "bad DropAndReplace ({:?} = {:?}): {:?}",
-                        place_ty,
-                        rv_ty,
-                        terr
-                    );
-                }
-            }
             TerminatorKind::SwitchInt { ref discr, switch_ty, .. } => {
                 self.check_operand(discr, term_location);
 
@@ -1664,8 +1646,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 }
             }
             TerminatorKind::Unreachable => {}
-            TerminatorKind::Drop { target, unwind, .. }
-            | TerminatorKind::DropAndReplace { target, unwind, .. }
+            TerminatorKind::DropIfInit { target, unwind, .. }
+            | TerminatorKind::DropIf { target, unwind, .. }
             | TerminatorKind::Assert { target, cleanup: unwind, .. } => {
                 self.assert_iscleanup(body, block_data, target, is_cleanup);
                 if let Some(unwind) = unwind {

compiler/rustc_borrowck/src/used_muts.rs

@@ -71,9 +71,9 @@ impl<'visit, 'cx, 'tcx> Visitor<'tcx> for GatherUsedMutsVisitor<'visit, 'cx, 'tc
             TerminatorKind::Call { destination, .. } => {
                 self.remove_never_initialized_mut_locals(*destination);
             }
-            TerminatorKind::DropAndReplace { place, .. } => {
-                self.remove_never_initialized_mut_locals(*place);
-            }
+            // TerminatorKind::DropIfInit { place, .. } => {
+            //     self.remove_never_initialized_mut_locals(*place);
+            // }
             _ => {}
         }
 

compiler/rustc_codegen_cranelift/src/base.rs

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

compiler/rustc_codegen_cranelift/src/constant.rs

@@ -539,10 +539,10 @@ pub(crate) fn mir_operand_get_const_val<'tcx>(
                     | TerminatorKind::Abort
                     | TerminatorKind::Return
                     | TerminatorKind::Unreachable
-                    | TerminatorKind::Drop { .. }
+                    | TerminatorKind::DropIfInit { .. }
+                    | TerminatorKind::DropIf { .. }
                     | TerminatorKind::Assert { .. } => {}
-                    TerminatorKind::DropAndReplace { .. }
-                    | TerminatorKind::Yield { .. }
+                    TerminatorKind::Yield { .. }
                     | TerminatorKind::GeneratorDrop
                     | TerminatorKind::FalseEdge { .. }
                     | TerminatorKind::FalseUnwind { .. } => unreachable!(),

compiler/rustc_codegen_ssa/src/mir/analyze.rs

@@ -281,8 +281,8 @@ pub fn cleanup_kinds(mir: &mir::Body<'_>) -> IndexVec<mir::BasicBlock, CleanupKi
                 TerminatorKind::Call { cleanup: unwind, .. }
                 | TerminatorKind::InlineAsm { cleanup: unwind, .. }
                 | TerminatorKind::Assert { cleanup: unwind, .. }
-                | TerminatorKind::DropAndReplace { unwind, .. }
-                | TerminatorKind::Drop { unwind, .. } => {
+                | TerminatorKind::DropIf { unwind, .. }
+                | TerminatorKind::DropIfInit { unwind, .. } => {
                     if let Some(unwind) = unwind {
                         debug!(
                             "cleanup_kinds: {:?}/{:?} registering {:?} as funclet",