Rename MaybeUnreachable.

1 files changed, 30 insertions, 25 deletions

diff --git a/compiler/rustc_mir_dataflow/src/framework/lattice.rs b/compiler/rustc_mir_dataflow/src/framework/lattice.rs
index 72ebf5754be..3b89598d289 100644
--- a/compiler/rustc_mir_dataflow/src/framework/lattice.rs
+++ b/compiler/rustc_mir_dataflow/src/framework/lattice.rs
@@ -273,69 +273,75 @@ impl<T> HasTop for FlatSet<T> {
     const TOP: Self = Self::Top;
 }
 
+/// Extend a lattice with a bottom value to represent an unreachable execution.
+///
+/// The only useful action on an unreachable state is joining it with a reachable one to make it
+/// reachable. All other actions, gen/kill for instance, are no-ops.
 #[derive(PartialEq, Eq, Debug)]
-pub enum MaybeUnreachable<T> {
+pub enum MaybeReachable<T> {
     Unreachable,
     Reachable(T),
 }
 
-impl<T> MaybeUnreachable<T> {
+impl<T> MaybeReachable<T> {
     pub fn is_reachable(&self) -> bool {
-        matches!(self, MaybeUnreachable::Reachable(_))
+        matches!(self, MaybeReachable::Reachable(_))
     }
 }
 
-impl<T> HasBottom for MaybeUnreachable<T> {
-    const BOTTOM: Self = MaybeUnreachable::Unreachable;
+impl<T> HasBottom for MaybeReachable<T> {
+    const BOTTOM: Self = MaybeReachable::Unreachable;
 }
 
-impl<T: HasTop> HasTop for MaybeUnreachable<T> {
-    const TOP: Self = MaybeUnreachable::Reachable(T::TOP);
+impl<T: HasTop> HasTop for MaybeReachable<T> {
+    const TOP: Self = MaybeReachable::Reachable(T::TOP);
 }
 
-impl<S> MaybeUnreachable<S> {
+impl<S> MaybeReachable<S> {
+    /// Return whether the current state contains the given element. If the state is unreachable,
+    /// it does no contain anything.
     pub fn contains<T>(&self, elem: T) -> bool
     where
         S: BitSetExt<T>,
     {
         match self {
-            MaybeUnreachable::Unreachable => false,
-            MaybeUnreachable::Reachable(set) => set.contains(elem),
+            MaybeReachable::Unreachable => false,
+            MaybeReachable::Reachable(set) => set.contains(elem),
         }
     }
 }
 
-impl<T, S: BitSetExt<T>> BitSetExt<T> for MaybeUnreachable<S> {
+impl<T, S: BitSetExt<T>> BitSetExt<T> for MaybeReachable<S> {
     fn contains(&self, elem: T) -> bool {
         self.contains(elem)
     }
 
     fn union(&mut self, other: &HybridBitSet<T>) {
         match self {
-            MaybeUnreachable::Unreachable => {}
-            MaybeUnreachable::Reachable(set) => set.union(other),
+            MaybeReachable::Unreachable => {}
+            MaybeReachable::Reachable(set) => set.union(other),
         }
     }
 
     fn subtract(&mut self, other: &HybridBitSet<T>) {
         match self {
-            MaybeUnreachable::Unreachable => {}
-            MaybeUnreachable::Reachable(set) => set.subtract(other),
+            MaybeReachable::Unreachable => {}
+            MaybeReachable::Reachable(set) => set.subtract(other),
         }
     }
 }
 
-impl<V: Clone> Clone for MaybeUnreachable<V> {
+impl<V: Clone> Clone for MaybeReachable<V> {
     fn clone(&self) -> Self {
         match self {
-            MaybeUnreachable::Reachable(x) => MaybeUnreachable::Reachable(x.clone()),
-            MaybeUnreachable::Unreachable => MaybeUnreachable::Unreachable,
+            MaybeReachable::Reachable(x) => MaybeReachable::Reachable(x.clone()),
+            MaybeReachable::Unreachable => MaybeReachable::Unreachable,
         }
     }
 
     fn clone_from(&mut self, source: &Self) {
         match (&mut *self, source) {
-            (MaybeUnreachable::Reachable(x), MaybeUnreachable::Reachable(y)) => {
+            (MaybeReachable::Reachable(x), MaybeReachable::Reachable(y)) => {
                 x.clone_from(&y);
             }
             _ => *self = source.clone(),
@@ -343,17 +349,16 @@ impl<V: Clone> Clone for MaybeUnreachable<V> {
     }
 }
 
-impl<T: JoinSemiLattice + Clone> JoinSemiLattice for MaybeUnreachable<T> {
+impl<T: JoinSemiLattice + Clone> JoinSemiLattice for MaybeReachable<T> {
     fn join(&mut self, other: &Self) -> bool {
+        // Unreachable acts as a bottom.
         match (&mut *self, &other) {
-            (_, MaybeUnreachable::Unreachable) => false,
-            (MaybeUnreachable::Unreachable, _) => {
+            (_, MaybeReachable::Unreachable) => false,
+            (MaybeReachable::Unreachable, _) => {
                 *self = other.clone();
                 true
             }
-            (MaybeUnreachable::Reachable(this), MaybeUnreachable::Reachable(other)) => {
-                this.join(other)
-            }
+            (MaybeReachable::Reachable(this), MaybeReachable::Reachable(other)) => this.join(other),
         }
     }
 }