@@ -12,7 +12,7 @@ use crate::framework::SwitchIntEdgeEffects;
1212use crate::move_paths::{HasMoveData, InitIndex, InitKind, LookupResult, MoveData, MovePathIndex};
1313use crate::{
1414 Analysis, GenKill, MaybeReachable, drop_flag_effects, drop_flag_effects_for_function_entry,
15- drop_flag_effects_for_location, lattice, on_all_children_bits, on_lookup_result_bits,
15+ drop_flag_effects_for_location, on_all_children_bits, on_lookup_result_bits,
1616};
1717
1818/// `MaybeInitializedPlaces` tracks all places that might be
@@ -42,10 +42,10 @@ use crate::{
4242/// }
4343/// ```
4444///
45- /// To determine whether a place *must* be initialized at a
46- /// particular control-flow point, one can take the set-difference
47- /// between this data and the data from `MaybeUninitializedPlaces` at the
48- /// corresponding control-flow point.
45+ /// To determine whether a place is *definitely* initialized at a
46+ /// particular control-flow point, one can take the set-complement
47+ /// of the data from `MaybeUninitializedPlaces` at the corresponding
48+ /// control-flow point.
4949///
5050/// Similarly, at a given `drop` statement, the set-intersection
5151/// between this data and `MaybeUninitializedPlaces` yields the set of
@@ -117,10 +117,10 @@ impl<'a, 'tcx> HasMoveData<'tcx> for MaybeInitializedPlaces<'a, 'tcx> {
117117/// }
118118/// ```
119119///
120- /// To determine whether a place *must* be uninitialized at a
121- /// particular control-flow point, one can take the set-difference
122- /// between this data and the data from `MaybeInitializedPlaces` at the
123- /// corresponding control-flow point.
120+ /// To determine whether a place is *definitely* uninitialized at a
121+ /// particular control-flow point, one can take the set-complement
122+ /// of the data from `MaybeInitializedPlaces` at the corresponding
123+ /// control-flow point.
124124///
125125/// Similarly, at a given `drop` statement, the set-intersection
126126/// between this data and `MaybeInitializedPlaces` yields the set of
@@ -170,57 +170,6 @@ impl<'tcx> HasMoveData<'tcx> for MaybeUninitializedPlaces<'_, 'tcx> {
170170 }
171171}
172172
173- /// `DefinitelyInitializedPlaces` tracks all places that are definitely
174- /// initialized upon reaching a particular point in the control flow
175- /// for a function.
176- ///
177- /// For example, in code like the following, we have corresponding
178- /// dataflow information shown in the right-hand comments.
179- ///
180- /// ```rust
181- /// struct S;
182- /// fn foo(pred: bool) { // definite-init:
183- /// // { }
184- /// let a = S; let mut b = S; let c; let d; // {a, b }
185- ///
186- /// if pred {
187- /// drop(a); // { b, }
188- /// b = S; // { b, }
189- ///
190- /// } else {
191- /// drop(b); // {a, }
192- /// d = S; // {a, d}
193- ///
194- /// } // { }
195- ///
196- /// c = S; // { c }
197- /// }
198- /// ```
199- ///
200- /// To determine whether a place *may* be uninitialized at a
201- /// particular control-flow point, one can take the set-complement
202- /// of this data.
203- ///
204- /// Similarly, at a given `drop` statement, the set-difference between
205- /// this data and `MaybeInitializedPlaces` yields the set of places
206- /// that would require a dynamic drop-flag at that statement.
207- pub struct DefinitelyInitializedPlaces<'a, 'tcx> {
208- body: &'a Body<'tcx>,
209- move_data: &'a MoveData<'tcx>,
210- }
211-
212- impl<'a, 'tcx> DefinitelyInitializedPlaces<'a, 'tcx> {
213- pub fn new(body: &'a Body<'tcx>, move_data: &'a MoveData<'tcx>) -> Self {
214- DefinitelyInitializedPlaces { body, move_data }
215- }
216- }
217-
218- impl<'a, 'tcx> HasMoveData<'tcx> for DefinitelyInitializedPlaces<'a, 'tcx> {
219- fn move_data(&self) -> &MoveData<'tcx> {
220- self.move_data
221- }
222- }
223-
224173/// `EverInitializedPlaces` tracks all places that might have ever been
225174/// initialized upon reaching a particular point in the control flow
226175/// for a function, without an intervening `StorageDead`.
@@ -293,19 +242,6 @@ impl<'tcx> MaybeUninitializedPlaces<'_, 'tcx> {
293242 }
294243}
295244
296- impl<'a, 'tcx> DefinitelyInitializedPlaces<'a, 'tcx> {
297- fn update_bits(
298- trans: &mut <Self as Analysis<'tcx>>::Domain,
299- path: MovePathIndex,
300- state: DropFlagState,
301- ) {
302- match state {
303- DropFlagState::Absent => trans.kill(path),
304- DropFlagState::Present => trans.gen_(path),
305- }
306- }
307- }
308-
309245impl<'tcx> Analysis<'tcx> for MaybeInitializedPlaces<'_, 'tcx> {
310246 /// There can be many more `MovePathIndex` than there are locals in a MIR body.
311247 /// We use a chunked bitset to avoid paying too high a memory footprint.
@@ -554,70 +490,6 @@ impl<'tcx> Analysis<'tcx> for MaybeUninitializedPlaces<'_, 'tcx> {
554490 }
555491}
556492
557- impl<'a, 'tcx> Analysis<'tcx> for DefinitelyInitializedPlaces<'a, 'tcx> {
558- /// Use set intersection as the join operator.
559- type Domain = lattice::Dual<BitSet<MovePathIndex>>;
560-
561- const NAME: &'static str = "definite_init";
562-
563- fn bottom_value(&self, _: &mir::Body<'tcx>) -> Self::Domain {
564- // bottom = initialized (start_block_effect counters this at outset)
565- lattice::Dual(BitSet::new_filled(self.move_data().move_paths.len()))
566- }
567-
568- // sets on_entry bits for Arg places
569- fn initialize_start_block(&self, _: &mir::Body<'tcx>, state: &mut Self::Domain) {
570- state.0.clear();
571-
572- drop_flag_effects_for_function_entry(self.body, self.move_data, |path, s| {
573- assert!(s == DropFlagState::Present);
574- state.0.insert(path);
575- });
576- }
577-
578- fn apply_statement_effect(
579- &mut self,
580- trans: &mut Self::Domain,
581- _statement: &mir::Statement<'tcx>,
582- location: Location,
583- ) {
584- drop_flag_effects_for_location(self.body, self.move_data, location, |path, s| {
585- Self::update_bits(trans, path, s)
586- })
587- }
588-
589- fn apply_terminator_effect<'mir>(
590- &mut self,
591- trans: &mut Self::Domain,
592- terminator: &'mir mir::Terminator<'tcx>,
593- location: Location,
594- ) -> TerminatorEdges<'mir, 'tcx> {
595- drop_flag_effects_for_location(self.body, self.move_data, location, |path, s| {
596- Self::update_bits(trans, path, s)
597- });
598- terminator.edges()
599- }
600-
601- fn apply_call_return_effect(
602- &mut self,
603- trans: &mut Self::Domain,
604- _block: mir::BasicBlock,
605- return_places: CallReturnPlaces<'_, 'tcx>,
606- ) {
607- return_places.for_each(|place| {
608- // when a call returns successfully, that means we need to set
609- // the bits for that dest_place to 1 (initialized).
610- on_lookup_result_bits(
611- self.move_data(),
612- self.move_data().rev_lookup.find(place.as_ref()),
613- |mpi| {
614- trans.gen_(mpi);
615- },
616- );
617- });
618- }
619- }
620-
621493impl<'tcx> Analysis<'tcx> for EverInitializedPlaces<'_, 'tcx> {
622494 /// There can be many more `InitIndex` than there are locals in a MIR body.
623495 /// We use a chunked bitset to avoid paying too high a memory footprint.
0 commit comments