Change type of SwitchIntTarget::value.

`SwitchIntTarget` only exists to serve as an input to
`Analysis::apply_switch_int_edge_effect`. `SwitchIntTarget::value` is
and `Option<u128>` but all non-empty impls of
`apply_switch_int_edge_effect` ignore any `SwitchIntTarget` that
contains a `None` value. Therefore, we can remove the
`apply_switch_int_edge_effect` calls that pass in `None`, and simplify
the `Option<u128>` to `u128`.

Author: nnethercote

compiler/rustc_mir_dataflow/src/framework/direction.rs

@@ -115,8 +115,11 @@ 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);
-                            let si_target = SwitchIntTarget { value, target: block };
-                            analysis.apply_switch_int_edge_effect(&mut data, &mut tmp, si_target);
+                            if let Some(value) = value {
+                                let si_target = SwitchIntTarget { value, target: block };
+                                analysis
+                                    .apply_switch_int_edge_effect(&mut data, &mut tmp, si_target);
+                            }
                             propagate(pred, &tmp);
                         }
                     } else {
@@ -290,21 +293,11 @@ impl Direction for Forward {
                     let mut tmp = analysis.bottom_value(body);
                     for (value, target) in targets.iter() {
                         tmp.clone_from(exit_state);
-                        let si_target = SwitchIntTarget { value: Some(value), target };
+                        let si_target = SwitchIntTarget { value, target };
                         analysis.apply_switch_int_edge_effect(&mut data, &mut tmp, si_target);
                         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,
-                        SwitchIntTarget { value: None, target: otherwise },
-                    );
-                    propagate(otherwise, exit_state);
+                    propagate(targets.otherwise(), exit_state);
                 } else {
                     for target in targets.all_targets() {
                         propagate(*target, exit_state);

compiler/rustc_mir_dataflow/src/framework/mod.rs

@@ -199,8 +199,8 @@ pub trait Analysis<'tcx> {
     /// Unlike the other edge-specific effects, which are allowed to mutate `Self::Domain`
     /// directly, overriders of this method must return a `Self::SwitchIntData` value (wrapped in
     /// `Some`). The `apply_switch_int_edge_effect` method will then be called once for each
-    /// outgoing edge and will have access to the dataflow state that will be propagated along that
-    /// edge, and also the `Self::SwitchIntData` value.
+    /// outgoing edge (excluding the "otherwise" target) and will have access to the dataflow
+    /// state that will be propagated along that edge, and also the `Self::SwitchIntData` value.
     ///
     /// This interface is somewhat more complex than the other visitor-like "effect" methods.
     /// However, it is both more ergonomic—callers don't need to recompute or cache information
@@ -431,7 +431,7 @@ impl EffectIndex {
 }
 
 pub struct SwitchIntTarget {
-    pub value: Option<u128>,
+    pub value: u128,
     pub target: BasicBlock,
 }
 

compiler/rustc_mir_dataflow/src/impls/initialized.rs

@@ -424,16 +424,14 @@ impl<'tcx> Analysis<'tcx> for MaybeInitializedPlaces<'_, 'tcx> {
         state: &mut Self::Domain,
         edge: SwitchIntTarget,
     ) {
-        if let Some(value) = edge.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_inactive_variants(
-                self.move_data,
-                data.enum_place,
-                data.next_discr(value),
-                |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`.
+        drop_flag_effects::on_all_inactive_variants(
+            self.move_data,
+            data.enum_place,
+            data.next_discr(edge.value),
+            |mpi| state.kill(mpi),
+        );
     }
 }
 
@@ -537,16 +535,14 @@ impl<'tcx> Analysis<'tcx> for MaybeUninitializedPlaces<'_, 'tcx> {
         state: &mut Self::Domain,
         edge: SwitchIntTarget,
     ) {
-        if let Some(value) = edge.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_inactive_variants(
-                self.move_data,
-                data.enum_place,
-                data.next_discr(value),
-                |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).
+        drop_flag_effects::on_all_inactive_variants(
+            self.move_data,
+            data.enum_place,
+            data.next_discr(edge.value),
+            |mpi| state.gen_(mpi),
+        );
     }
 }