make on_all_variants argument not Option

Author: ashivaram23

compiler/rustc_mir_dataflow/src/drop_flag_effects.rs

@@ -156,14 +156,14 @@ where
 }
 
 /// Handles each variant that corresponds to one of the child move paths of `enum_place`. If the
-/// variant is `active_variant`, `handle_active_variant` will be called (if provided). Otherwise,
+/// variant is `active_variant`, `handle_active_variant` will be called. Otherwise,
 /// `handle_inactive_variant` will be called.
 pub(crate) fn on_all_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: Option<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;
@@ -183,7 +183,7 @@ pub(crate) fn on_all_variants<'tcx>(
 
         if variant_idx != active_variant {
             on_all_children_bits(move_data, variant_mpi, |mpi| handle_inactive_variant(mpi));
-        } else if let Some(ref mut handle_active_variant) = handle_active_variant {
+        } else {
             on_all_children_bits(move_data, variant_mpi, |mpi| handle_active_variant(mpi));
         }
     }

compiler/rustc_mir_dataflow/src/impls/initialized.rs

@@ -456,16 +456,33 @@ impl<'tcx> Analysis<'tcx> for MaybeInitializedPlaces<'_, 'tcx> {
         value: SwitchTargetValue,
         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
-            // particular outgoing edge of a `SwitchInt`.
-            drop_flag_effects::on_all_variants(
-                self.move_data,
-                data.enum_place,
-                data.next_discr(value),
-                |mpi| state.kill(mpi),
-                otherwise_state.map(|state| |mpi| state.kill(mpi)),
-            );
+        let SwitchTargetValue::Normal(value) = value else {
+            return;
+        };
+
+        let handle_inactive_variant = |mpi| state.kill(mpi);
+
+        // Kill all move paths that correspond to variants we know to be inactive along this
+        // particular outgoing edge of a `SwitchInt`.
+        match otherwise_state {
+            Some(otherwise_state) => {
+                drop_flag_effects::on_all_variants(
+                    self.move_data,
+                    data.enum_place,
+                    data.next_discr(value),
+                    handle_inactive_variant,
+                    |mpi| otherwise_state.kill(mpi),
+                );
+            }
+            None => {
+                drop_flag_effects::on_all_variants(
+                    self.move_data,
+                    data.enum_place,
+                    data.next_discr(value),
+                    handle_inactive_variant,
+                    |_mpi| {},
+                );
+            }
         }
     }
 
@@ -598,16 +615,33 @@ impl<'tcx> Analysis<'tcx> for MaybeUninitializedPlaces<'_, 'tcx> {
         value: SwitchTargetValue,
         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
-            // uninitialized (in reality, they are *definitely* uninitialized).
-            drop_flag_effects::on_all_variants(
-                self.move_data,
-                data.enum_place,
-                data.next_discr(value),
-                |mpi| state.gen_(mpi),
-                otherwise_state.map(|state| |mpi| state.gen_(mpi)),
-            );
+        let SwitchTargetValue::Normal(value) = value else {
+            return;
+        };
+
+        let handle_inactive_variant = |mpi| state.gen_(mpi);
+
+        // Mark all move paths that correspond to variants other than this one as maybe
+        // uninitialized (in reality, they are *definitely* uninitialized).
+        match otherwise_state {
+            Some(otherwise_state) => {
+                drop_flag_effects::on_all_variants(
+                    self.move_data,
+                    data.enum_place,
+                    data.next_discr(value),
+                    handle_inactive_variant,
+                    |mpi| otherwise_state.gen_(mpi),
+                );
+            }
+            None => {
+                drop_flag_effects::on_all_variants(
+                    self.move_data,
+                    data.enum_place,
+                    data.next_discr(value),
+                    handle_inactive_variant,
+                    |_mpi| {},
+                );
+            }
         }
     }