Skip to content
This repository was archived by the owner on May 28, 2025. It is now read-only.

Commit 6cf15d4

Browse files
cjgillotcjgillot
committed
Rename MaybeUnreachable.
1 parent f19cd3f commit 6cf15d4

File tree

6 files changed

+55
-49
lines changed

6 files changed

+55
-49
lines changed

‎compiler/rustc_mir_dataflow/src/framework/fmt.rs

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
//! Custom formatting traits used when outputting Graphviz diagrams with the results of a dataflow
22
//! analysis.
33
4-
use super::lattice::MaybeUnreachable;
4+
use super::lattice::MaybeReachable;
55
use rustc_index::bit_set::{BitSet, ChunkedBitSet, HybridBitSet};
66
use rustc_index::Idx;
77
use std::fmt;
@@ -125,31 +125,31 @@ where
125125
}
126126
}
127127

128-
impl<S, C> DebugWithContext<C> for MaybeUnreachable<S>
128+
impl<S, C> DebugWithContext<C> for MaybeReachable<S>
129129
where
130130
S: DebugWithContext<C>,
131131
{
132132
fn fmt_with(&self, ctxt: &C, f: &mut fmt::Formatter<'_>) -> fmt::Result {
133133
match self {
134-
MaybeUnreachable::Unreachable => {
134+
MaybeReachable::Unreachable => {
135135
write!(f, "unreachable")
136136
}
137-
MaybeUnreachable::Reachable(set) => set.fmt_with(ctxt, f),
137+
MaybeReachable::Reachable(set) => set.fmt_with(ctxt, f),
138138
}
139139
}
140140

141141
fn fmt_diff_with(&self, old: &Self, ctxt: &C, f: &mut fmt::Formatter<'_>) -> fmt::Result {
142142
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)) => {
145145
write!(f, "\u{001f}+")?;
146146
set.fmt_with(ctxt, f)
147147
}
148-
(MaybeUnreachable::Reachable(set), MaybeUnreachable::Unreachable) => {
148+
(MaybeReachable::Reachable(set), MaybeReachable::Unreachable) => {
149149
write!(f, "\u{001f}-")?;
150150
set.fmt_with(ctxt, f)
151151
}
152-
(MaybeUnreachable::Reachable(this), MaybeUnreachable::Reachable(old)) => {
152+
(MaybeReachable::Reachable(this), MaybeReachable::Reachable(old)) => {
153153
this.fmt_diff_with(old, ctxt, f)
154154
}
155155
}

‎compiler/rustc_mir_dataflow/src/framework/lattice.rs

Lines changed: 30 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -273,87 +273,92 @@ impl<T> HasTop for FlatSet<T> {
273273
const TOP: Self = Self::Top;
274274
}
275275

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.
276280
#[derive(PartialEq, Eq, Debug)]
277-
pub enum MaybeUnreachable<T> {
281+
pub enum MaybeReachable<T> {
278282
Unreachable,
279283
Reachable(T),
280284
}
281285

282-
impl<T> MaybeUnreachable<T> {
286+
impl<T> MaybeReachable<T> {
283287
pub fn is_reachable(&self) -> bool {
284-
matches!(self, MaybeUnreachable::Reachable(_))
288+
matches!(self, MaybeReachable::Reachable(_))
285289
}
286290
}
287291

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;
290294
}
291295

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);
294298
}
295299

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.
297303
pub fn contains<T>(&self, elem: T) -> bool
298304
where
299305
S: BitSetExt<T>,
300306
{
301307
match self {
302-
MaybeUnreachable::Unreachable => false,
303-
MaybeUnreachable::Reachable(set) => set.contains(elem),
308+
MaybeReachable::Unreachable => false,
309+
MaybeReachable::Reachable(set) => set.contains(elem),
304310
}
305311
}
306312
}
307313

308-
impl<T, S: BitSetExt<T>> BitSetExt<T> for MaybeUnreachable<S> {
314+
impl<T, S: BitSetExt<T>> BitSetExt<T> for MaybeReachable<S> {
309315
fn contains(&self, elem: T) -> bool {
310316
self.contains(elem)
311317
}
312318

313319
fn union(&mut self, other: &HybridBitSet<T>) {
314320
match self {
315-
MaybeUnreachable::Unreachable => {}
316-
MaybeUnreachable::Reachable(set) => set.union(other),
321+
MaybeReachable::Unreachable => {}
322+
MaybeReachable::Reachable(set) => set.union(other),
317323
}
318324
}
319325

320326
fn subtract(&mut self, other: &HybridBitSet<T>) {
321327
match self {
322-
MaybeUnreachable::Unreachable => {}
323-
MaybeUnreachable::Reachable(set) => set.subtract(other),
328+
MaybeReachable::Unreachable => {}
329+
MaybeReachable::Reachable(set) => set.subtract(other),
324330
}
325331
}
326332
}
327333

328-
impl<V: Clone> Clone for MaybeUnreachable<V> {
334+
impl<V: Clone> Clone for MaybeReachable<V> {
329335
fn clone(&self) -> Self {
330336
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,
333339
}
334340
}
335341

336342
fn clone_from(&mut self, source: &Self) {
337343
match (&mut *self, source) {
338-
(MaybeUnreachable::Reachable(x), MaybeUnreachable::Reachable(y)) => {
344+
(MaybeReachable::Reachable(x), MaybeReachable::Reachable(y)) => {
339345
x.clone_from(&y);
340346
}
341347
_ => *self = source.clone(),
342348
}
343349
}
344350
}
345351

346-
impl<T: JoinSemiLattice + Clone> JoinSemiLattice for MaybeUnreachable<T> {
352+
impl<T: JoinSemiLattice + Clone> JoinSemiLattice for MaybeReachable<T> {
347353
fn join(&mut self, other: &Self) -> bool {
354+
// Unreachable acts as a bottom.
348355
match (&mut *self, &other) {
349-
(_, MaybeUnreachable::Unreachable) => false,
350-
(MaybeUnreachable::Unreachable, _) => {
356+
(_, MaybeReachable::Unreachable) => false,
357+
(MaybeReachable::Unreachable, _) => {
351358
*self = other.clone();
352359
true
353360
}
354-
(MaybeUnreachable::Reachable(this), MaybeUnreachable::Reachable(other)) => {
355-
this.join(other)
356-
}
361+
(MaybeReachable::Reachable(this), MaybeReachable::Reachable(other)) => this.join(other),
357362
}
358363
}
359364
}

‎compiler/rustc_mir_dataflow/src/framework/mod.rs

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,7 @@ mod visitor;
4848
pub use self::cursor::{AnalysisResults, ResultsClonedCursor, ResultsCursor, ResultsRefCursor};
4949
pub use self::direction::{Backward, Direction, Forward};
5050
pub use self::engine::{Engine, EntrySets, Results, ResultsCloned};
51-
pub use self::lattice::{JoinSemiLattice, MaybeUnreachable, MeetSemiLattice};
51+
pub use self::lattice::{JoinSemiLattice, MaybeReachable, MeetSemiLattice};
5252
pub use self::visitor::{visit_results, ResultsVisitable, ResultsVisitor};
5353

5454
/// Analysis domains are all bitsets of various kinds. This trait holds
@@ -492,18 +492,20 @@ impl<T: Idx> GenKill<T> for ChunkedBitSet<T> {
492492
}
493493
}
494494

495-
impl<T, S: GenKill<T>> GenKill<T> for MaybeUnreachable<S> {
495+
impl<T, S: GenKill<T>> GenKill<T> for MaybeReachable<S> {
496496
fn gen(&mut self, elem: T) {
497497
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),
500501
}
501502
}
502503

503504
fn kill(&mut self, elem: T) {
504505
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),
507509
}
508510
}
509511
}

‎compiler/rustc_mir_dataflow/src/impls/initialized.rs

Lines changed: 6 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ use crate::move_paths::{HasMoveData, InitIndex, InitKind, LookupResult, MoveData
1111
use crate::on_lookup_result_bits;
1212
use crate::MoveDataParamEnv;
1313
use crate::{drop_flag_effects, on_all_children_bits, on_all_drop_children_bits};
14-
use crate::{lattice, AnalysisDomain, GenKill, GenKillAnalysis, MaybeUnreachable};
14+
use crate::{lattice, AnalysisDomain, GenKill, GenKillAnalysis, MaybeReachable};
1515

1616
/// `MaybeInitializedPlaces` tracks all places that might be
1717
/// initialized upon reaching a particular point in the control flow
@@ -68,7 +68,7 @@ impl<'a, 'tcx> MaybeInitializedPlaces<'a, 'tcx> {
6868
pub fn is_unwind_dead(
6969
&self,
7070
place: mir::Place<'tcx>,
71-
state: &MaybeUnreachable<ChunkedBitSet<MovePathIndex>>,
71+
state: &MaybeReachable<ChunkedBitSet<MovePathIndex>>,
7272
) -> bool {
7373
if let LookupResult::Exact(path) = self.move_data().rev_lookup.find(place.as_ref()) {
7474
let mut maybe_live = false;
@@ -308,18 +308,17 @@ impl<'a, 'tcx> DefinitelyInitializedPlaces<'a, 'tcx> {
308308
}
309309

310310
impl<'tcx> AnalysisDomain<'tcx> for MaybeInitializedPlaces<'_, 'tcx> {
311-
type Domain = MaybeUnreachable<ChunkedBitSet<MovePathIndex>>;
311+
type Domain = MaybeReachable<ChunkedBitSet<MovePathIndex>>;
312312
const NAME: &'static str = "maybe_init";
313313

314314
fn bottom_value(&self, _: &mir::Body<'tcx>) -> Self::Domain {
315315
// bottom = uninitialized
316-
MaybeUnreachable::Unreachable
316+
MaybeReachable::Unreachable
317317
}
318318

319319
fn initialize_start_block(&self, _: &mir::Body<'tcx>, state: &mut Self::Domain) {
320-
*state = MaybeUnreachable::Reachable(ChunkedBitSet::new_empty(
321-
self.move_data().move_paths.len(),
322-
));
320+
*state =
321+
MaybeReachable::Reachable(ChunkedBitSet::new_empty(self.move_data().move_paths.len()));
323322
drop_flag_effects_for_function_entry(self.tcx, self.body, self.mdpe, |path, s| {
324323
assert!(s == DropFlagState::Present);
325324
state.gen(path);

‎compiler/rustc_mir_dataflow/src/lib.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@ pub use self::drop_flag_effects::{
2929
pub use self::framework::{
3030
fmt, graphviz, lattice, visit_results, Analysis, AnalysisDomain, AnalysisResults, Backward,
3131
CloneAnalysis, Direction, Engine, Forward, GenKill, GenKillAnalysis, JoinSemiLattice,
32-
MaybeUnreachable, Results, ResultsCloned, ResultsClonedCursor, ResultsCursor, ResultsRefCursor,
32+
MaybeReachable, Results, ResultsCloned, ResultsClonedCursor, ResultsCursor, ResultsRefCursor,
3333
ResultsVisitable, ResultsVisitor, SwitchIntEdgeEffects,
3434
};
3535

‎compiler/rustc_mir_transform/src/remove_uninit_drops.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ use rustc_middle::ty::{self, ParamEnv, Ty, TyCtxt, VariantDef};
55
use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
66
use rustc_mir_dataflow::move_paths::{LookupResult, MoveData, MovePathIndex};
77
use rustc_mir_dataflow::{
8-
self, move_path_children_matching, Analysis, MaybeUnreachable, MoveDataParamEnv,
8+
self, move_path_children_matching, Analysis, MaybeReachable, MoveDataParamEnv,
99
};
1010
use rustc_target::abi::FieldIdx;
1111

@@ -43,7 +43,7 @@ impl<'tcx> MirPass<'tcx> for RemoveUninitDrops {
4343
let TerminatorKind::Drop { place, .. } = &terminator.kind else { continue };
4444

4545
maybe_inits.seek_before_primary_effect(body.terminator_loc(bb));
46-
let MaybeUnreachable::Reachable(maybe_inits) = maybe_inits.get() else { continue };
46+
let MaybeReachable::Reachable(maybe_inits) = maybe_inits.get() else { continue };
4747

4848
// If there's no move path for the dropped place, it's probably a `Deref`. Let it alone.
4949
let LookupResult::Exact(mpi) = mdpe.move_data.rev_lookup.find(place.as_ref()) else {

0 commit comments

Comments
 (0)