Auto merge of #142707 - ashivaram23:drop_wildcard, r=<try>

Update `MaybeUninitializedPlaces` and `MaybeInitializedPlaces` for `otherwise`

<!-- homu-ignore:start -->
<!--
If this PR is related to an unstable feature or an otherwise tracked effort,
please link to the relevant tracking issue here. If you don't know of a related
tracking issue or there are none, feel free to ignore this.

This PR will get automatically assigned to a reviewer. In case you would like
a specific user to review your work, you can assign it to them by using

    r? <reviewer name>
-->
<!-- homu-ignore:end -->

This allows `ElaborateDrops` to remove drops when a `match` wildcard arm covers multiple no-Drop enum variants. It modifies dataflow analysis to update the `MaybeUninitializedPlaces` and `MaybeInitializedPlaces` data for a block reached through an `otherwise` edge.

This appears to fix #142705, but I don't know for sure if it's actually correct (are there cases where this would be wrong and break things?). I also haven't tested that it actually improves compile times, or machine code output outside of the examples in the issue.

Author: rust-bors[bot]

compiler/rustc_mir_dataflow/src/drop_flag_effects.rs

@@ -156,15 +156,16 @@ where
 }
 
 /// Calls `handle_inactive_variant` for each descendant move path of `enum_place` that contains a
-/// `Downcast` to a variant besides the `active_variant`.
+/// `Downcast` to a variant besides the `active_variant`, otherwise calls `handle_active_variant`.
 ///
-/// NOTE: If there are no move paths corresponding to an inactive variant,
-/// `handle_inactive_variant` will not be called for that variant.
+/// NOTE: If there are no move paths corresponding to an inactive variant, `handle_active_variant`
+/// or `handle_inactive_variant` will not be called for that variant.
 pub(crate) fn on_all_inactive_variants<'tcx>(
     move_data: &MoveData<'tcx>,
     enum_place: mir::Place<'tcx>,
     active_variant: VariantIdx,
     mut handle_inactive_variant: impl FnMut(MovePathIndex),
+    mut handle_active_variant: impl FnMut(MovePathIndex),
 ) {
     let LookupResult::Exact(enum_mpi) = move_data.rev_lookup.find(enum_place.as_ref()) else {
         return;
@@ -184,6 +185,8 @@ pub(crate) fn on_all_inactive_variants<'tcx>(
 
         if variant_idx != active_variant {
             on_all_children_bits(move_data, variant_mpi, |mpi| handle_inactive_variant(mpi));
+        } else {
+            on_all_children_bits(move_data, variant_mpi, |mpi| handle_active_variant(mpi));
         }
     }
 }

compiler/rustc_mir_dataflow/src/framework/direction.rs

@@ -117,7 +117,7 @@ impl Direction for Backward {
                         let mut tmp = analysis.bottom_value(body);
                         for &value in &body.basic_blocks.switch_sources()[&(block, pred)] {
                             tmp.clone_from(exit_state);
-                            analysis.apply_switch_int_edge_effect(&mut data, &mut tmp, value);
+                            analysis.apply_switch_int_edge_effect(&mut data, &mut tmp, value, None);
                             propagate(pred, &tmp);
                         }
                     } else {
@@ -287,23 +287,21 @@ impl Direction for Forward {
             TerminatorEdges::SwitchInt { targets, discr } => {
                 if let Some(mut data) = analysis.get_switch_int_data(block, discr) {
                     let mut tmp = analysis.bottom_value(body);
+                    let mut otherwise_state = exit_state.clone();
+
                     for (value, target) in targets.iter() {
                         tmp.clone_from(exit_state);
                         let value = SwitchTargetValue::Normal(value);
-                        analysis.apply_switch_int_edge_effect(&mut data, &mut tmp, value);
+                        analysis.apply_switch_int_edge_effect(
+                            &mut data,
+                            &mut tmp,
+                            value,
+                            Some(&mut otherwise_state),
+                        );
                         propagate(target, &tmp);
                     }
 
-                    // Once we get to the final, "otherwise" branch, there is no need to preserve
-                    // `exit_state`, so pass it directly to `apply_switch_int_edge_effect` to save
-                    // a clone of the dataflow state.
-                    let otherwise = targets.otherwise();
-                    analysis.apply_switch_int_edge_effect(
-                        &mut data,
-                        exit_state,
-                        SwitchTargetValue::Otherwise,
-                    );
-                    propagate(otherwise, exit_state);
+                    propagate(targets.otherwise(), &otherwise_state);
                 } else {
                     for target in targets.all_targets() {
                         propagate(*target, exit_state);

compiler/rustc_mir_dataflow/src/framework/mod.rs

@@ -224,6 +224,7 @@ pub trait Analysis<'tcx> {
         _data: &mut Self::SwitchIntData,
         _state: &mut Self::Domain,
         _value: SwitchTargetValue,
+        _otherwise_state: Option<&mut Self::Domain>,
     ) {
         unreachable!();
     }

compiler/rustc_mir_dataflow/src/impls/initialized.rs

@@ -431,6 +431,7 @@ impl<'tcx> Analysis<'tcx> for MaybeInitializedPlaces<'_, 'tcx> {
         data: &mut Self::SwitchIntData,
         state: &mut Self::Domain,
         value: SwitchTargetValue,
+        mut otherwise_state: Option<&mut Self::Domain>,
     ) {
         if let SwitchTargetValue::Normal(value) = value {
             // Kill all move paths that correspond to variants we know to be inactive along this
@@ -440,6 +441,9 @@ impl<'tcx> Analysis<'tcx> for MaybeInitializedPlaces<'_, 'tcx> {
                 data.enum_place,
                 data.next_discr(value),
                 |mpi| state.kill(mpi),
+                move |mpi| {
+                    otherwise_state.as_mut().map(|state| state.kill(mpi));
+                },
             );
         }
     }
@@ -544,6 +548,7 @@ impl<'tcx> Analysis<'tcx> for MaybeUninitializedPlaces<'_, 'tcx> {
         data: &mut Self::SwitchIntData,
         state: &mut Self::Domain,
         value: SwitchTargetValue,
+        mut otherwise_state: Option<&mut Self::Domain>,
     ) {
         if let SwitchTargetValue::Normal(value) = value {
             // Mark all move paths that correspond to variants other than this one as maybe
@@ -553,6 +558,9 @@ impl<'tcx> Analysis<'tcx> for MaybeUninitializedPlaces<'_, 'tcx> {
                 data.enum_place,
                 data.next_discr(value),
                 |mpi| state.gen_(mpi),
+                |mpi| {
+                    otherwise_state.as_mut().map(|state| state.gen_(mpi));
+                },
             );
         }
     }