Elaborate comment.

Author: cjgillot

compiler/rustc_mir_transform/src/dest_prop.rs

@@ -547,6 +547,21 @@ fn save_as_intervals<'tcx>(
                 }
             }
         };
+    let second_half_visitor = |mark_reads| {
+        VisitPlacesWith(|place: Place<'tcx>, ctxt| {
+            if let Some(relevant) = relevant.shrink[place.local] {
+                match DefUse::for_place(place, ctxt) {
+                    DefUse::Def | DefUse::PartialWrite => {
+                        values.insert(relevant, twostep);
+                    }
+                    DefUse::Use if mark_reads => {
+                        values.insert(relevant, twostep);
+                    }
+                    DefUse::NonUse => {}
+                }
+            }
+        })
+    };
 
     // Iterate blocks in decreasing order, to visit locations in decreasing order. This
     // allows to use the more efficient `append` method to interval sets.
@@ -567,17 +582,7 @@ fn save_as_intervals<'tcx>(
         // the written-to locals as live in the second half of the statement.
         // We also ensure that operands read by terminators conflict with writes by that terminator.
         // For instance a function call may read args after having written to the destination.
-        VisitPlacesWith(|place: Place<'tcx>, ctxt| {
-            if let Some(relevant) = relevant.shrink[place.local] {
-                match DefUse::for_place(place, ctxt) {
-                    DefUse::Def | DefUse::Use | DefUse::PartialWrite => {
-                        values.insert(relevant, twostep);
-                    }
-                    DefUse::NonUse => {}
-                }
-            }
-        })
-        .visit_terminator(term, loc);
+        second_half_visitor(/* mark reads */ true).visit_terminator(term, loc);
 
         twostep = TwoStepIndex::from_u32(twostep.as_u32() + 1);
         debug_assert_eq!(twostep, two_step_loc(loc, Effect::Before));
@@ -590,24 +595,15 @@ fn save_as_intervals<'tcx>(
             twostep = TwoStepIndex::from_u32(twostep.as_u32() + 1);
             debug_assert_eq!(twostep, two_step_loc(loc, Effect::After));
             append_at(&mut values, &state, twostep);
-            // Ensure we have a non-zero live range even for dead stores. This is done by marking
-            // all the written-to locals as live in the second half of the statement.
+            // Like terminators, ensure we have a non-zero live range even for dead stores.
+            // Some rvalues interleave reads and writes, for instance `Rvalue::Aggregate`, see
+            // https://github.com/rust-lang/rust/issues/146383. By precaution, treat statements
+            // as behaving so by default.
+            // We make an exception for simple assignments `_a.stuff = {copy|move} _b.stuff`,
+            // as marking `_b` live here would prevent unification.
             let is_simple_assignment =
                 matches!(stmt.kind, StatementKind::Assign(box (_, Rvalue::Use(_))));
-            VisitPlacesWith(|place: Place<'tcx>, ctxt| {
-                if let Some(relevant) = relevant.shrink[place.local] {
-                    match DefUse::for_place(place, ctxt) {
-                        DefUse::Def | DefUse::PartialWrite => {
-                            values.insert(relevant, twostep);
-                        }
-                        DefUse::Use if !is_simple_assignment => {
-                            values.insert(relevant, twostep);
-                        }
-                        DefUse::Use | DefUse::NonUse => {}
-                    }
-                }
-            })
-            .visit_statement(stmt, loc);
+            second_half_visitor(/* mark reads */ is_simple_assignment).visit_statement(stmt, loc);
 
             twostep = TwoStepIndex::from_u32(twostep.as_u32() + 1);
             debug_assert_eq!(twostep, two_step_loc(loc, Effect::Before));