Use new dataflow interface for initialization/borrows analyses

Author: ecstatic-morse

src/librustc_mir/dataflow/impls/borrows.rs

@@ -10,7 +10,8 @@ use crate::borrow_check::{
     places_conflict, BorrowData, BorrowSet, PlaceConflictBias, PlaceExt, RegionInferenceContext,
     ToRegionVid,
 };
-use crate::dataflow::{BitDenotation, BottomValue, GenKillSet};
+use crate::dataflow::generic::{self, GenKill};
+use crate::dataflow::BottomValue;
 
 use std::rc::Rc;
 
@@ -172,7 +173,7 @@ impl<'a, 'tcx> Borrows<'a, 'tcx> {
     /// That means they went out of a nonlexical scope
     fn kill_loans_out_of_scope_at_location(
         &self,
-        trans: &mut GenKillSet<BorrowIndex>,
+        trans: &mut impl GenKill<BorrowIndex>,
         location: Location,
     ) {
         // NOTE: The state associated with a given `location`
@@ -187,16 +188,21 @@ impl<'a, 'tcx> Borrows<'a, 'tcx> {
         // region, then setting that gen-bit will override any
         // potential kill introduced here.
         if let Some(indices) = self.borrows_out_of_scope_at_location.get(&location) {
-            trans.kill_all(indices);
+            trans.kill_all(indices.iter().copied());
         }
     }
 
     /// Kill any borrows that conflict with `place`.
-    fn kill_borrows_on_place(&self, trans: &mut GenKillSet<BorrowIndex>, place: &Place<'tcx>) {
+    fn kill_borrows_on_place(&self, trans: &mut impl GenKill<BorrowIndex>, place: &Place<'tcx>) {
         debug!("kill_borrows_on_place: place={:?}", place);
 
-        let other_borrows_of_local =
-            self.borrow_set.local_map.get(&place.local).into_iter().flat_map(|bs| bs.into_iter());
+        let other_borrows_of_local = self
+            .borrow_set
+            .local_map
+            .get(&place.local)
+            .into_iter()
+            .flat_map(|bs| bs.into_iter())
+            .copied();
 
         // If the borrowed place is a local with no projections, all other borrows of this
         // local must conflict. This is purely an optimization so we don't have to call
@@ -212,7 +218,7 @@ impl<'a, 'tcx> Borrows<'a, 'tcx> {
         // pair of array indices are unequal, so that when `places_conflict` returns true, we
         // will be assured that two places being compared definitely denotes the same sets of
         // locations.
-        let definitely_conflicting_borrows = other_borrows_of_local.filter(|&&i| {
+        let definitely_conflicting_borrows = other_borrows_of_local.filter(|&i| {
             places_conflict(
                 self.tcx,
                 self.body,
@@ -226,36 +232,41 @@ impl<'a, 'tcx> Borrows<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> BitDenotation<'tcx> for Borrows<'a, 'tcx> {
+impl<'tcx> generic::AnalysisDomain<'tcx> for Borrows<'_, 'tcx> {
     type Idx = BorrowIndex;
-    fn name() -> &'static str {
-        "borrows"
-    }
-    fn bits_per_block(&self) -> usize {
+
+    const NAME: &'static str = "borrows";
+
+    fn bits_per_block(&self, _: &mir::Body<'tcx>) -> usize {
         self.borrow_set.borrows.len() * 2
     }
 
-    fn start_block_effect(&self, _entry_set: &mut BitSet<Self::Idx>) {
+    fn initialize_start_block(&self, _: &mir::Body<'tcx>, _: &mut BitSet<Self::Idx>) {
         // no borrows of code region_scopes have been taken prior to
         // function execution, so this method has no effect.
     }
 
-    fn before_statement_effect(&self, trans: &mut GenKillSet<Self::Idx>, location: Location) {
-        debug!("Borrows::before_statement_effect trans: {:?} location: {:?}", trans, location);
-        self.kill_loans_out_of_scope_at_location(trans, location);
+    fn pretty_print_idx(&self, w: &mut impl std::io::Write, idx: Self::Idx) -> std::io::Result<()> {
+        write!(w, "{:?}", self.location(idx))
     }
+}
 
-    fn statement_effect(&self, trans: &mut GenKillSet<Self::Idx>, location: Location) {
-        debug!("Borrows::statement_effect: trans={:?} location={:?}", trans, location);
-
-        let block = &self.body.basic_blocks().get(location.block).unwrap_or_else(|| {
-            panic!("could not find block at location {:?}", location);
-        });
-        let stmt = block.statements.get(location.statement_index).unwrap_or_else(|| {
-            panic!("could not find statement at location {:?}");
-        });
+impl<'tcx> generic::GenKillAnalysis<'tcx> for Borrows<'_, 'tcx> {
+    fn before_statement_effect(
+        &self,
+        trans: &mut impl GenKill<Self::Idx>,
+        _statement: &mir::Statement<'tcx>,
+        location: Location,
+    ) {
+        self.kill_loans_out_of_scope_at_location(trans, location);
+    }
 
-        debug!("Borrows::statement_effect: stmt={:?}", stmt);
+    fn statement_effect(
+        &self,
+        trans: &mut impl GenKill<Self::Idx>,
+        stmt: &mir::Statement<'tcx>,
+        location: Location,
+    ) {
         match stmt.kind {
             mir::StatementKind::Assign(box (ref lhs, ref rhs)) => {
                 if let mir::Rvalue::Ref(_, _, ref place) = *rhs {
@@ -301,18 +312,29 @@ impl<'a, 'tcx> BitDenotation<'tcx> for Borrows<'a, 'tcx> {
         }
     }
 
-    fn before_terminator_effect(&self, trans: &mut GenKillSet<Self::Idx>, location: Location) {
-        debug!("Borrows::before_terminator_effect: trans={:?} location={:?}", trans, location);
+    fn before_terminator_effect(
+        &self,
+        trans: &mut impl GenKill<Self::Idx>,
+        _terminator: &mir::Terminator<'tcx>,
+        location: Location,
+    ) {
         self.kill_loans_out_of_scope_at_location(trans, location);
     }
 
-    fn terminator_effect(&self, _: &mut GenKillSet<Self::Idx>, _: Location) {}
+    fn terminator_effect(
+        &self,
+        _: &mut impl GenKill<Self::Idx>,
+        _: &mir::Terminator<'tcx>,
+        _: Location,
+    ) {
+    }
 
-    fn propagate_call_return(
+    fn call_return_effect(
         &self,
-        _in_out: &mut BitSet<BorrowIndex>,
-        _call_bb: mir::BasicBlock,
-        _dest_bb: mir::BasicBlock,
+        _trans: &mut impl GenKill<Self::Idx>,
+        _block: mir::BasicBlock,
+        _func: &mir::Operand<'tcx>,
+        _args: &[mir::Operand<'tcx>],
         _dest_place: &mir::Place<'tcx>,
     ) {
     }