Rename MaybeUnreachable.

cjgillot · cjgillot · commit 6cf15d4cb5bf · 2023-08-16T18:12:18.000Z
diff --git a/compiler/rustc_mir_dataflow/src/framework/fmt.rs b/compiler/rustc_mir_dataflow/src/framework/fmt.rs
@@ -1,7 +1,7 @@
 //! Custom formatting traits used when outputting Graphviz diagrams with the results of a dataflow
 //! analysis.
 
-use super::lattice::MaybeUnreachable;
+use super::lattice::MaybeReachable;
 use rustc_index::bit_set::{BitSet, ChunkedBitSet, HybridBitSet};
 use rustc_index::Idx;
 use std::fmt;
@@ -125,31 +125,31 @@ where
     }
 }
 
-impl<S, C> DebugWithContext<C> for MaybeUnreachable<S>
+impl<S, C> DebugWithContext<C> for MaybeReachable<S>
 where
     S: DebugWithContext<C>,
 {
     fn fmt_with(&self, ctxt: &C, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            MaybeUnreachable::Unreachable => {
+            MaybeReachable::Unreachable => {
                 write!(f, "unreachable")
             }
-            MaybeUnreachable::Reachable(set) => set.fmt_with(ctxt, f),
+            MaybeReachable::Reachable(set) => set.fmt_with(ctxt, f),
         }
     }
 
     fn fmt_diff_with(&self, old: &Self, ctxt: &C, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match (self, old) {
-            (MaybeUnreachable::Unreachable, MaybeUnreachable::Unreachable) => Ok(()),
-            (MaybeUnreachable::Unreachable, MaybeUnreachable::Reachable(set)) => {
+            (MaybeReachable::Unreachable, MaybeReachable::Unreachable) => Ok(()),
+            (MaybeReachable::Unreachable, MaybeReachable::Reachable(set)) => {
                 write!(f, "\u{001f}+")?;
                 set.fmt_with(ctxt, f)
             }
-            (MaybeUnreachable::Reachable(set), MaybeUnreachable::Unreachable) => {
+            (MaybeReachable::Reachable(set), MaybeReachable::Unreachable) => {
                 write!(f, "\u{001f}-")?;
                 set.fmt_with(ctxt, f)
             }
-            (MaybeUnreachable::Reachable(this), MaybeUnreachable::Reachable(old)) => {
+            (MaybeReachable::Reachable(this), MaybeReachable::Reachable(old)) => {
                 this.fmt_diff_with(old, ctxt, f)
             }
         }
diff --git a/compiler/rustc_mir_dataflow/src/framework/lattice.rs b/compiler/rustc_mir_dataflow/src/framework/lattice.rs
@@ -273,87 +273,92 @@ 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(),
         }
     }
 }
 
-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),
         }
     }
 }
diff --git a/compiler/rustc_mir_dataflow/src/framework/mod.rs b/compiler/rustc_mir_dataflow/src/framework/mod.rs
@@ -48,7 +48,7 @@ mod visitor;
 pub use self::cursor::{AnalysisResults, ResultsClonedCursor, ResultsCursor, ResultsRefCursor};
 pub use self::direction::{Backward, Direction, Forward};
 pub use self::engine::{Engine, EntrySets, Results, ResultsCloned};
-pub use self::lattice::{JoinSemiLattice, MaybeUnreachable, MeetSemiLattice};
+pub use self::lattice::{JoinSemiLattice, MaybeReachable, MeetSemiLattice};
 pub use self::visitor::{visit_results, ResultsVisitable, ResultsVisitor};
 
 /// Analysis domains are all bitsets of various kinds. This trait holds
@@ -492,18 +492,20 @@ impl<T: Idx> GenKill<T> for ChunkedBitSet<T> {
     }
 }
 
-impl<T, S: GenKill<T>> GenKill<T> for MaybeUnreachable<S> {
+impl<T, S: GenKill<T>> GenKill<T> for MaybeReachable<S> {
     fn gen(&mut self, elem: T) {
         match self {
-            MaybeUnreachable::Unreachable => {}
-            MaybeUnreachable::Reachable(set) => set.gen(elem),
+            // If the state is not reachable, adding an element does nothing.
+            MaybeReachable::Unreachable => {}
+            MaybeReachable::Reachable(set) => set.gen(elem),
         }
     }
 
     fn kill(&mut self, elem: T) {
         match self {
-            MaybeUnreachable::Unreachable => {}
-            MaybeUnreachable::Reachable(set) => set.kill(elem),
+            // If the state is not reachable, killing an element does nothing.
+            MaybeReachable::Unreachable => {}
+            MaybeReachable::Reachable(set) => set.kill(elem),
         }
     }
 }
diff --git a/compiler/rustc_mir_dataflow/src/impls/initialized.rs b/compiler/rustc_mir_dataflow/src/impls/initialized.rs
@@ -11,7 +11,7 @@ use crate::move_paths::{HasMoveData, InitIndex, InitKind, LookupResult, MoveData
 use crate::on_lookup_result_bits;
 use crate::MoveDataParamEnv;
 use crate::{drop_flag_effects, on_all_children_bits, on_all_drop_children_bits};
-use crate::{lattice, AnalysisDomain, GenKill, GenKillAnalysis, MaybeUnreachable};
+use crate::{lattice, AnalysisDomain, GenKill, GenKillAnalysis, MaybeReachable};
 
 /// `MaybeInitializedPlaces` tracks all places that might be
 /// initialized upon reaching a particular point in the control flow
@@ -68,7 +68,7 @@ impl<'a, 'tcx> MaybeInitializedPlaces<'a, 'tcx> {
     pub fn is_unwind_dead(
         &self,
         place: mir::Place<'tcx>,
-        state: &MaybeUnreachable<ChunkedBitSet<MovePathIndex>>,
+        state: &MaybeReachable<ChunkedBitSet<MovePathIndex>>,
     ) -> bool {
         if let LookupResult::Exact(path) = self.move_data().rev_lookup.find(place.as_ref()) {
             let mut maybe_live = false;
@@ -308,18 +308,17 @@ impl<'a, 'tcx> DefinitelyInitializedPlaces<'a, 'tcx> {
 }
 
 impl<'tcx> AnalysisDomain<'tcx> for MaybeInitializedPlaces<'_, 'tcx> {
-    type Domain = MaybeUnreachable<ChunkedBitSet<MovePathIndex>>;
+    type Domain = MaybeReachable<ChunkedBitSet<MovePathIndex>>;
     const NAME: &'static str = "maybe_init";
 
     fn bottom_value(&self, _: &mir::Body<'tcx>) -> Self::Domain {
         // bottom = uninitialized
-        MaybeUnreachable::Unreachable
+        MaybeReachable::Unreachable
     }
 
     fn initialize_start_block(&self, _: &mir::Body<'tcx>, state: &mut Self::Domain) {
-        *state = MaybeUnreachable::Reachable(ChunkedBitSet::new_empty(
-            self.move_data().move_paths.len(),
-        ));
+        *state =
+            MaybeReachable::Reachable(ChunkedBitSet::new_empty(self.move_data().move_paths.len()));
         drop_flag_effects_for_function_entry(self.tcx, self.body, self.mdpe, |path, s| {
             assert!(s == DropFlagState::Present);
             state.gen(path);
diff --git a/compiler/rustc_mir_dataflow/src/lib.rs b/compiler/rustc_mir_dataflow/src/lib.rs
@@ -29,7 +29,7 @@ pub use self::drop_flag_effects::{
 pub use self::framework::{
     fmt, graphviz, lattice, visit_results, Analysis, AnalysisDomain, AnalysisResults, Backward,
     CloneAnalysis, Direction, Engine, Forward, GenKill, GenKillAnalysis, JoinSemiLattice,
-    MaybeUnreachable, Results, ResultsCloned, ResultsClonedCursor, ResultsCursor, ResultsRefCursor,
+    MaybeReachable, Results, ResultsCloned, ResultsClonedCursor, ResultsCursor, ResultsRefCursor,
     ResultsVisitable, ResultsVisitor, SwitchIntEdgeEffects,
 };
 
diff --git a/compiler/rustc_mir_transform/src/remove_uninit_drops.rs b/compiler/rustc_mir_transform/src/remove_uninit_drops.rs
@@ -5,7 +5,7 @@ use rustc_middle::ty::{self, ParamEnv, Ty, TyCtxt, VariantDef};
 use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
 use rustc_mir_dataflow::move_paths::{LookupResult, MoveData, MovePathIndex};
 use rustc_mir_dataflow::{
-    self, move_path_children_matching, Analysis, MaybeUnreachable, MoveDataParamEnv,
+    self, move_path_children_matching, Analysis, MaybeReachable, MoveDataParamEnv,
 };
 use rustc_target::abi::FieldIdx;
 
@@ -43,7 +43,7 @@ impl<'tcx> MirPass<'tcx> for RemoveUninitDrops {
             let TerminatorKind::Drop { place, .. } = &terminator.kind else { continue };
 
             maybe_inits.seek_before_primary_effect(body.terminator_loc(bb));
-            let MaybeUnreachable::Reachable(maybe_inits) = maybe_inits.get() else { continue };
+            let MaybeReachable::Reachable(maybe_inits) = maybe_inits.get() else { continue };
 
             // If there's no move path for the dropped place, it's probably a `Deref`. Let it alone.
             let LookupResult::Exact(mpi) = mdpe.move_data.rev_lookup.find(place.as_ref()) else {

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`//! Custom formatting traits used when outputting Graphviz diagrams with the results of a dataflow`
`2`	`2`	`//! analysis.`
`3`	`3`
`4`		`-use super::lattice::MaybeUnreachable;`
	`4`	`+use super::lattice::MaybeReachable;`
`5`	`5`	`use rustc_index::bit_set::{BitSet, ChunkedBitSet, HybridBitSet};`
`6`	`6`	`use rustc_index::Idx;`
`7`	`7`	`use std::fmt;`
`@@ -125,31 +125,31 @@ where`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`
`128`		`-impl<S, C> DebugWithContext<C> for MaybeUnreachable<S>`
	`128`	`+impl<S, C> DebugWithContext<C> for MaybeReachable<S>`
`129`	`129`	`where`
`130`	`130`	`S: DebugWithContext<C>,`
`131`	`131`	`{`
`132`	`132`	`fn fmt_with(&self, ctxt: &C, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`133`	`133`	`match self {`
`134`		`- MaybeUnreachable::Unreachable => {`
	`134`	`+ MaybeReachable::Unreachable => {`
`135`	`135`	`write!(f, "unreachable")`
`136`	`136`	`}`
`137`		`- MaybeUnreachable::Reachable(set) => set.fmt_with(ctxt, f),`
	`137`	`+ MaybeReachable::Reachable(set) => set.fmt_with(ctxt, f),`
`138`	`138`	`}`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`fn fmt_diff_with(&self, old: &Self, ctxt: &C, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`142`	`142`	`match (self, old) {`
`143`		`- (MaybeUnreachable::Unreachable, MaybeUnreachable::Unreachable) => Ok(()),`
`144`		`- (MaybeUnreachable::Unreachable, MaybeUnreachable::Reachable(set)) => {`
	`143`	`+ (MaybeReachable::Unreachable, MaybeReachable::Unreachable) => Ok(()),`
	`144`	`+ (MaybeReachable::Unreachable, MaybeReachable::Reachable(set)) => {`
`145`	`145`	`write!(f, "\u{001f}+")?;`
`146`	`146`	`set.fmt_with(ctxt, f)`
`147`	`147`	`}`
`148`		`- (MaybeUnreachable::Reachable(set), MaybeUnreachable::Unreachable) => {`
	`148`	`+ (MaybeReachable::Reachable(set), MaybeReachable::Unreachable) => {`
`149`	`149`	`write!(f, "\u{001f}-")?;`
`150`	`150`	`set.fmt_with(ctxt, f)`
`151`	`151`	`}`
`152`		`- (MaybeUnreachable::Reachable(this), MaybeUnreachable::Reachable(old)) => {`
	`152`	`+ (MaybeReachable::Reachable(this), MaybeReachable::Reachable(old)) => {`
`153`	`153`	`this.fmt_diff_with(old, ctxt, f)`
`154`	`154`	`}`
`155`	`155`	`}`
Original file line number	Diff line number	Diff line change
`@@ -273,87 +273,92 @@ impl<T> HasTop for FlatSet<T> {`
`273`	`273`	`const TOP: Self = Self::Top;`
`274`	`274`	`}`
`275`	`275`
	`276`	`+/// Extend a lattice with a bottom value to represent an unreachable execution.`
	`277`	`+///`
	`278`	`+/// The only useful action on an unreachable state is joining it with a reachable one to make it`
	`279`	`+/// reachable. All other actions, gen/kill for instance, are no-ops.`
`276`	`280`	`#[derive(PartialEq, Eq, Debug)]`
`277`		`-pub enum MaybeUnreachable<T> {`
	`281`	`+pub enum MaybeReachable<T> {`
`278`	`282`	`Unreachable,`
`279`	`283`	`Reachable(T),`
`280`	`284`	`}`
`281`	`285`
`282`		`-impl<T> MaybeUnreachable<T> {`
	`286`	`+impl<T> MaybeReachable<T> {`
`283`	`287`	`pub fn is_reachable(&self) -> bool {`
`284`		`- matches!(self, MaybeUnreachable::Reachable(_))`
	`288`	`+ matches!(self, MaybeReachable::Reachable(_))`
`285`	`289`	`}`
`286`	`290`	`}`
`287`	`291`
`288`		`-impl<T> HasBottom for MaybeUnreachable<T> {`
`289`		`- const BOTTOM: Self = MaybeUnreachable::Unreachable;`
	`292`	`+impl<T> HasBottom for MaybeReachable<T> {`
	`293`	`+ const BOTTOM: Self = MaybeReachable::Unreachable;`
`290`	`294`	`}`
`291`	`295`
`292`		`-impl<T: HasTop> HasTop for MaybeUnreachable<T> {`
`293`		`- const TOP: Self = MaybeUnreachable::Reachable(T::TOP);`
	`296`	`+impl<T: HasTop> HasTop for MaybeReachable<T> {`
	`297`	`+ const TOP: Self = MaybeReachable::Reachable(T::TOP);`
`294`	`298`	`}`
`295`	`299`
`296`		`-impl<S> MaybeUnreachable<S> {`
	`300`	`+impl<S> MaybeReachable<S> {`
	`301`	`+ /// Return whether the current state contains the given element. If the state is unreachable,`
	`302`	`+ /// it does no contain anything.`
`297`	`303`	`pub fn contains<T>(&self, elem: T) -> bool`
`298`	`304`	`where`
`299`	`305`	`S: BitSetExt<T>,`
`300`	`306`	`{`
`301`	`307`	`match self {`
`302`		`- MaybeUnreachable::Unreachable => false,`
`303`		`- MaybeUnreachable::Reachable(set) => set.contains(elem),`
	`308`	`+ MaybeReachable::Unreachable => false,`
	`309`	`+ MaybeReachable::Reachable(set) => set.contains(elem),`
`304`	`310`	`}`
`305`	`311`	`}`
`306`	`312`	`}`
`307`	`313`
`308`		`-impl<T, S: BitSetExt<T>> BitSetExt<T> for MaybeUnreachable<S> {`
	`314`	`+impl<T, S: BitSetExt<T>> BitSetExt<T> for MaybeReachable<S> {`
`309`	`315`	`fn contains(&self, elem: T) -> bool {`
`310`	`316`	`self.contains(elem)`
`311`	`317`	`}`
`312`	`318`
`313`	`319`	`fn union(&mut self, other: &HybridBitSet<T>) {`
`314`	`320`	`match self {`
`315`		`- MaybeUnreachable::Unreachable => {}`
`316`		`- MaybeUnreachable::Reachable(set) => set.union(other),`
	`321`	`+ MaybeReachable::Unreachable => {}`
	`322`	`+ MaybeReachable::Reachable(set) => set.union(other),`
`317`	`323`	`}`
`318`	`324`	`}`
`319`	`325`
`320`	`326`	`fn subtract(&mut self, other: &HybridBitSet<T>) {`
`321`	`327`	`match self {`
`322`		`- MaybeUnreachable::Unreachable => {}`
`323`		`- MaybeUnreachable::Reachable(set) => set.subtract(other),`
	`328`	`+ MaybeReachable::Unreachable => {}`
	`329`	`+ MaybeReachable::Reachable(set) => set.subtract(other),`
`324`	`330`	`}`
`325`	`331`	`}`
`326`	`332`	`}`
`327`	`333`
`328`		`-impl<V: Clone> Clone for MaybeUnreachable<V> {`
	`334`	`+impl<V: Clone> Clone for MaybeReachable<V> {`
`329`	`335`	`fn clone(&self) -> Self {`
`330`	`336`	`match self {`
`331`		`- MaybeUnreachable::Reachable(x) => MaybeUnreachable::Reachable(x.clone()),`
`332`		`- MaybeUnreachable::Unreachable => MaybeUnreachable::Unreachable,`
	`337`	`+ MaybeReachable::Reachable(x) => MaybeReachable::Reachable(x.clone()),`
	`338`	`+ MaybeReachable::Unreachable => MaybeReachable::Unreachable,`
`333`	`339`	`}`
`334`	`340`	`}`
`335`	`341`
`336`	`342`	`fn clone_from(&mut self, source: &Self) {`
`337`	`343`	`match (&mut *self, source) {`
`338`		`- (MaybeUnreachable::Reachable(x), MaybeUnreachable::Reachable(y)) => {`
	`344`	`+ (MaybeReachable::Reachable(x), MaybeReachable::Reachable(y)) => {`
`339`	`345`	`x.clone_from(&y);`
`340`	`346`	`}`
`341`	`347`	`_ => *self = source.clone(),`
`342`	`348`	`}`
`343`	`349`	`}`
`344`	`350`	`}`
`345`	`351`
`346`		`-impl<T: JoinSemiLattice + Clone> JoinSemiLattice for MaybeUnreachable<T> {`
	`352`	`+impl<T: JoinSemiLattice + Clone> JoinSemiLattice for MaybeReachable<T> {`
`347`	`353`	`fn join(&mut self, other: &Self) -> bool {`
	`354`	`+ // Unreachable acts as a bottom.`
`348`	`355`	`match (&mut *self, &other) {`
`349`		`- (_, MaybeUnreachable::Unreachable) => false,`
`350`		`- (MaybeUnreachable::Unreachable, _) => {`
	`356`	`+ (_, MaybeReachable::Unreachable) => false,`
	`357`	`+ (MaybeReachable::Unreachable, _) => {`
`351`	`358`	`*self = other.clone();`
`352`	`359`	`true`
`353`	`360`	`}`
`354`		`- (MaybeUnreachable::Reachable(this), MaybeUnreachable::Reachable(other)) => {`
`355`		`- this.join(other)`
`356`		`- }`
	`361`	`+ (MaybeReachable::Reachable(this), MaybeReachable::Reachable(other)) => this.join(other),`
`357`	`362`	`}`
`358`	`363`	`}`
`359`	`364`	`}`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ mod visitor;`
`48`	`48`	`pub use self::cursor::{AnalysisResults, ResultsClonedCursor, ResultsCursor, ResultsRefCursor};`
`49`	`49`	`pub use self::direction::{Backward, Direction, Forward};`
`50`	`50`	`pub use self::engine::{Engine, EntrySets, Results, ResultsCloned};`
`51`		`-pub use self::lattice::{JoinSemiLattice, MaybeUnreachable, MeetSemiLattice};`
	`51`	`+pub use self::lattice::{JoinSemiLattice, MaybeReachable, MeetSemiLattice};`
`52`	`52`	`pub use self::visitor::{visit_results, ResultsVisitable, ResultsVisitor};`
`53`	`53`
`54`	`54`	`/// Analysis domains are all bitsets of various kinds. This trait holds`
`@@ -492,18 +492,20 @@ impl<T: Idx> GenKill<T> for ChunkedBitSet<T> {`
`492`	`492`	`}`
`493`	`493`	`}`
`494`	`494`
`495`		`-impl<T, S: GenKill<T>> GenKill<T> for MaybeUnreachable<S> {`
	`495`	`+impl<T, S: GenKill<T>> GenKill<T> for MaybeReachable<S> {`
`496`	`496`	`fn gen(&mut self, elem: T) {`
`497`	`497`	`match self {`
`498`		`- MaybeUnreachable::Unreachable => {}`
`499`		`- MaybeUnreachable::Reachable(set) => set.gen(elem),`
	`498`	`+ // If the state is not reachable, adding an element does nothing.`
	`499`	`+ MaybeReachable::Unreachable => {}`
	`500`	`+ MaybeReachable::Reachable(set) => set.gen(elem),`
`500`	`501`	`}`
`501`	`502`	`}`
`502`	`503`
`503`	`504`	`fn kill(&mut self, elem: T) {`
`504`	`505`	`match self {`
`505`		`- MaybeUnreachable::Unreachable => {}`
`506`		`- MaybeUnreachable::Reachable(set) => set.kill(elem),`
	`506`	`+ // If the state is not reachable, killing an element does nothing.`
	`507`	`+ MaybeReachable::Unreachable => {}`
	`508`	`+ MaybeReachable::Reachable(set) => set.kill(elem),`
`507`	`509`	`}`
`508`	`510`	`}`
`509`	`511`	`}`