Simplify SwitchSources.

`SwitchSources` is a hashmap containing `SmallVec<[Option<u128>; 1]>`
elements. Each `SmallVec` has a predictable form: N `Some` elements
followed by a single `None` element.

This commit removes the trailing `None` element, changes the
`Option<u128>` to `u128`, and adjusts the single `switch_sources`
callsite to account for this (by adding a single unrolled loop iteration
for the elided `None` element, which simplifies down to a single
`propagate` call).

Author: nnethercote

compiler/rustc_middle/src/mir/basic_blocks.rs

@@ -20,7 +20,7 @@ pub struct BasicBlocks<'tcx> {
 // Typically 95%+ of basic blocks have 4 or fewer predecessors.
 type Predecessors = IndexVec<BasicBlock, SmallVec<[BasicBlock; 4]>>;
 
-type SwitchSources = FxHashMap<(BasicBlock, BasicBlock), SmallVec<[Option<u128>; 1]>>;
+type SwitchSources = FxHashMap<(BasicBlock, BasicBlock), SmallVec<[u128; 1]>>;
 
 #[derive(Clone, Default, Debug)]
 struct Cache {
@@ -71,7 +71,8 @@ impl<'tcx> BasicBlocks<'tcx> {
     }
 
     /// `switch_sources()[&(target, switch)]` returns a list of switch
-    /// values that lead to a `target` block from a `switch` block.
+    /// values that lead to a `target` block from a `switch` block. Excludes
+    /// the "otherwise" target.
     #[inline]
     pub fn switch_sources(&self) -> &SwitchSources {
         self.cache.switch_sources.get_or_init(|| {
@@ -82,9 +83,8 @@ impl<'tcx> BasicBlocks<'tcx> {
                 }) = &data.terminator
                 {
                     for (value, target) in targets.iter() {
-                        switch_sources.entry((target, bb)).or_default().push(Some(value));
+                        switch_sources.entry((target, bb)).or_default().push(value);
                     }
-                    switch_sources.entry((targets.otherwise(), bb)).or_default().push(None);
                 }
             }
             switch_sources

compiler/rustc_mir_dataflow/src/framework/direction.rs

@@ -115,13 +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);
-                            if let Some(value) = value {
-                                let si_target = SwitchIntTarget { value, target: block };
-                                analysis
-                                    .apply_switch_int_edge_effect(&mut data, &mut tmp, si_target);
-                            }
+                            let si_target = SwitchIntTarget { value, target: block };
+                            analysis.apply_switch_int_edge_effect(&mut data, &mut tmp, si_target);
                             propagate(pred, &tmp);
                         }
+                        propagate(pred, exit_state);
                     } else {
                         propagate(pred, exit_state)
                     }