Put Analysis back into Results.

`Results` used to contain an `Analysis`, but it was removed in rust-lang#140234.
That change made sense because the analysis was mutable but the entry
states were immutable and it was good to separate them so the mutability
of the different pieces was clear.

Now that analyses are immutable there is no need for the separation,
lots of analysis+results pairs can be combined, and the names are going
back to what they were before:
- `Results` -> `EntryStates`
- `AnalysisAndResults` -> `Results`

Author: nnethercote

compiler/rustc_borrowck/src/lib.rs

@@ -49,7 +49,7 @@ use rustc_mir_dataflow::move_paths::{
     InitIndex, InitLocation, LookupResult, MoveData, MovePathIndex,
 };
 use rustc_mir_dataflow::points::DenseLocationMap;
-use rustc_mir_dataflow::{Analysis, Results, ResultsVisitor, visit_results};
+use rustc_mir_dataflow::{Analysis, EntryStates, Results, ResultsVisitor, visit_results};
 use rustc_session::lint::builtin::{TAIL_EXPR_DROP_ORDER, UNUSED_MUT};
 use rustc_span::{ErrorGuaranteed, Span, Symbol};
 use smallvec::SmallVec;
@@ -537,12 +537,10 @@ fn borrowck_check_region_constraints<'tcx>(
         mbcx.report_region_errors(nll_errors);
     }
 
-    let (flow_analysis, flow_results) =
-        get_flow_results(tcx, body, &move_data, &borrow_set, &regioncx);
+    let flow_results = get_flow_results(tcx, body, &move_data, &borrow_set, &regioncx);
     visit_results(
         body,
         traversal::reverse_postorder(body).map(|(bb, _)| bb),
-        &flow_analysis,
         &flow_results,
         &mut mbcx,
     );
@@ -604,7 +602,7 @@ fn get_flow_results<'a, 'tcx>(
     move_data: &'a MoveData<'tcx>,
     borrow_set: &'a BorrowSet<'tcx>,
     regioncx: &RegionInferenceContext<'tcx>,
-) -> (Borrowck<'a, 'tcx>, Results<BorrowckDomain>) {
+) -> Results<'tcx, Borrowck<'a, 'tcx>> {
     // We compute these three analyses individually, but them combine them into
     // a single results so that `mbcx` can visit them all together.
     let borrows = Borrows::new(tcx, body, regioncx, borrow_set).iterate_to_fixpoint(
@@ -629,14 +627,14 @@ fn get_flow_results<'a, 'tcx>(
         ever_inits: ever_inits.analysis,
     };
 
-    assert_eq!(borrows.results.len(), uninits.results.len());
-    assert_eq!(borrows.results.len(), ever_inits.results.len());
-    let results: Results<_> =
-        itertools::izip!(borrows.results, uninits.results, ever_inits.results)
+    assert_eq!(borrows.entry_states.len(), uninits.entry_states.len());
+    assert_eq!(borrows.entry_states.len(), ever_inits.entry_states.len());
+    let entry_states: EntryStates<_> =
+        itertools::izip!(borrows.entry_states, uninits.entry_states, ever_inits.entry_states)
             .map(|(borrows, uninits, ever_inits)| BorrowckDomain { borrows, uninits, ever_inits })
             .collect();
 
-    (analysis, results)
+    Results { analysis, entry_states }
 }
 
 pub(crate) struct BorrowckInferCtxt<'tcx> {

compiler/rustc_mir_dataflow/src/framework/cursor.rs

@@ -42,8 +42,7 @@ where
     A: Analysis<'tcx>,
 {
     body: &'mir mir::Body<'tcx>,
-    analysis: SimpleCow<'mir, A>,
-    results: SimpleCow<'mir, Results<A::Domain>>,
+    results: SimpleCow<'mir, Results<'tcx, A>>,
     state: A::Domain,
 
     pos: CursorPosition,
@@ -71,15 +70,10 @@ where
         self.body
     }
 
-    fn new(
-        body: &'mir mir::Body<'tcx>,
-        analysis: SimpleCow<'mir, A>,
-        results: SimpleCow<'mir, Results<A::Domain>>,
-    ) -> Self {
-        let bottom_value = analysis.bottom_value(body);
+    fn new(body: &'mir mir::Body<'tcx>, results: SimpleCow<'mir, Results<'tcx, A>>) -> Self {
+        let bottom_value = results.analysis.bottom_value(body);
         ResultsCursor {
             body,
-            analysis,
             results,
 
             // Initialize to the `bottom_value` and set `state_needs_reset` to tell the cursor that
@@ -95,21 +89,13 @@ where
     }
 
     /// Returns a new cursor that takes ownership of and inspects analysis results.
-    pub fn new_owning(
-        body: &'mir mir::Body<'tcx>,
-        analysis: A,
-        results: Results<A::Domain>,
-    ) -> Self {
-        Self::new(body, SimpleCow::Owned(analysis), SimpleCow::Owned(results))
+    pub fn new_owning(body: &'mir mir::Body<'tcx>, results: Results<'tcx, A>) -> Self {
+        Self::new(body, SimpleCow::Owned(results))
     }
 
     /// Returns a new cursor that borrows and inspects analysis results.
-    pub fn new_borrowing(
-        body: &'mir mir::Body<'tcx>,
-        analysis: &'mir A,
-        results: &'mir Results<A::Domain>,
-    ) -> Self {
-        Self::new(body, SimpleCow::Borrowed(analysis), SimpleCow::Borrowed(results))
+    pub fn new_borrowing(body: &'mir mir::Body<'tcx>, results: &'mir Results<'tcx, A>) -> Self {
+        Self::new(body, SimpleCow::Borrowed(results))
     }
 
     /// Allows inspection of unreachable basic blocks even with `debug_assertions` enabled.
@@ -121,7 +107,7 @@ where
 
     /// Returns the `Analysis` used to generate the underlying `Results`.
     pub fn analysis(&self) -> &A {
-        &self.analysis
+        &self.results.analysis
     }
 
     /// Resets the cursor to hold the entry set for the given basic block.
@@ -133,7 +119,7 @@ where
         #[cfg(debug_assertions)]
         assert!(self.reachable_blocks.contains(block));
 
-        self.state.clone_from(&self.results[block]);
+        self.state.clone_from(&self.results.entry_states[block]);
         self.pos = CursorPosition::block_entry(block);
         self.state_needs_reset = false;
     }
@@ -225,7 +211,7 @@ where
         let target_effect_index = effect.at_index(target.statement_index);
 
         A::Direction::apply_effects_in_range(
-            &*self.analysis,
+            &self.results.analysis,
             &mut self.state,
             target.block,
             block_data,
@@ -241,7 +227,7 @@ where
     /// This can be used, e.g., to apply the call return effect directly to the cursor without
     /// creating an extra copy of the dataflow state.
     pub fn apply_custom_effect(&mut self, f: impl FnOnce(&A, &mut A::Domain)) {
-        f(&self.analysis, &mut self.state);
+        f(&self.results.analysis, &mut self.state);
         self.state_needs_reset = true;
     }
 }

compiler/rustc_mir_dataflow/src/framework/graphviz.rs

@@ -32,8 +32,7 @@ use crate::errors::{
 pub(super) fn write_graphviz_results<'tcx, A>(
     tcx: TyCtxt<'tcx>,
     body: &Body<'tcx>,
-    analysis: &A,
-    results: &Results<A::Domain>,
+    results: &Results<'tcx, A>,
     pass_name: Option<&'static str>,
 ) -> std::io::Result<()>
 where
@@ -80,7 +79,7 @@ where
 
     let mut buf = Vec::new();
 
-    let graphviz = Formatter::new(body, analysis, results, style);
+    let graphviz = Formatter::new(body, results, style);
     let mut render_opts =
         vec![dot::RenderOption::Fontname(tcx.sess.opts.unstable_opts.graphviz_font.clone())];
     if tcx.sess.opts.unstable_opts.graphviz_dark_mode {
@@ -205,8 +204,7 @@ where
     A: Analysis<'tcx>,
 {
     body: &'mir Body<'tcx>,
-    analysis: &'mir A,
-    results: &'mir Results<A::Domain>,
+    results: &'mir Results<'tcx, A>,
     style: OutputStyle,
     reachable: DenseBitSet<BasicBlock>,
 }
@@ -215,14 +213,9 @@ impl<'mir, 'tcx, A> Formatter<'mir, 'tcx, A>
 where
     A: Analysis<'tcx>,
 {
-    fn new(
-        body: &'mir Body<'tcx>,
-        analysis: &'mir A,
-        results: &'mir Results<A::Domain>,
-        style: OutputStyle,
-    ) -> Self {
+    fn new(body: &'mir Body<'tcx>, results: &'mir Results<'tcx, A>, style: OutputStyle) -> Self {
         let reachable = traversal::reachable_as_bitset(body);
-        Formatter { body, analysis, results, style, reachable }
+        Formatter { body, results, style, reachable }
     }
 }
 
@@ -260,11 +253,10 @@ where
     }
 
     fn node_label(&self, block: &Self::Node) -> dot::LabelText<'_> {
-        let diffs =
-            StateDiffCollector::run(self.body, *block, self.analysis, self.results, self.style);
+        let diffs = StateDiffCollector::run(self.body, *block, self.results, self.style);
 
         let mut fmt = BlockFormatter {
-            cursor: ResultsCursor::new_borrowing(self.body, self.analysis, self.results),
+            cursor: ResultsCursor::new_borrowing(self.body, self.results),
             style: self.style,
             bg: Background::Light,
         };
@@ -692,21 +684,20 @@ impl<D> StateDiffCollector<D> {
     fn run<'tcx, A>(
         body: &Body<'tcx>,
         block: BasicBlock,
-        analysis: &A,
-        results: &Results<A::Domain>,
+        results: &Results<'tcx, A>,
         style: OutputStyle,
     ) -> Self
     where
         A: Analysis<'tcx, Domain = D>,
         D: DebugWithContext<A>,
     {
         let mut collector = StateDiffCollector {
-            prev_state: analysis.bottom_value(body),
+            prev_state: results.analysis.bottom_value(body),
             after: vec![],
             before: (style == OutputStyle::BeforeAndAfter).then_some(vec![]),
         };
 
-        visit_results(body, std::iter::once(block), analysis, results, &mut collector);
+        visit_results(body, std::iter::once(block), results, &mut collector);
         collector
     }
 }

compiler/rustc_mir_dataflow/src/framework/mod.rs

@@ -58,8 +58,7 @@ mod visitor;
 pub use self::cursor::ResultsCursor;
 pub use self::direction::{Backward, Direction, Forward};
 pub use self::lattice::{JoinSemiLattice, MaybeReachable};
-pub(crate) use self::results::AnalysisAndResults;
-pub use self::results::Results;
+pub use self::results::{EntryStates, Results};
 pub use self::visitor::{ResultsVisitor, visit_reachable_results, visit_results};
 
 /// Analysis domains are all bitsets of various kinds. This trait holds
@@ -249,15 +248,17 @@ pub trait Analysis<'tcx> {
         tcx: TyCtxt<'tcx>,
         body: &'mir mir::Body<'tcx>,
         pass_name: Option<&'static str>,
-    ) -> AnalysisAndResults<'tcx, Self>
+    ) -> Results<'tcx, Self>
     where
         Self: Sized,
         Self::Domain: DebugWithContext<Self>,
     {
-        let mut results = IndexVec::from_fn_n(|_| self.bottom_value(body), body.basic_blocks.len());
-        self.initialize_start_block(body, &mut results[mir::START_BLOCK]);
+        let mut entry_states =
+            IndexVec::from_fn_n(|_| self.bottom_value(body), body.basic_blocks.len());
+        self.initialize_start_block(body, &mut entry_states[mir::START_BLOCK]);
 
-        if Self::Direction::IS_BACKWARD && results[mir::START_BLOCK] != self.bottom_value(body) {
+        if Self::Direction::IS_BACKWARD && entry_states[mir::START_BLOCK] != self.bottom_value(body)
+        {
             bug!("`initialize_start_block` is not yet supported for backward dataflow analyses");
         }
 
@@ -281,8 +282,8 @@ pub trait Analysis<'tcx> {
         let mut state = self.bottom_value(body);
         while let Some(bb) = dirty_queue.pop() {
             // Set the state to the entry state of the block. This is equivalent to `state =
-            // results[bb].clone()`, but it saves an allocation, thus improving compile times.
-            state.clone_from(&results[bb]);
+            // entry_states[bb].clone()`, but it saves an allocation, thus improving compile times.
+            state.clone_from(&entry_states[bb]);
 
             Self::Direction::apply_effects_in_block(
                 &self,
@@ -291,22 +292,24 @@ pub trait Analysis<'tcx> {
                 bb,
                 &body[bb],
                 |target: BasicBlock, state: &Self::Domain| {
-                    let set_changed = results[target].join(state);
+                    let set_changed = entry_states[target].join(state);
                     if set_changed {
                         dirty_queue.insert(target);
                     }
                 },
             );
         }
 
+        let results = Results { analysis: self, entry_states };
+
         if tcx.sess.opts.unstable_opts.dump_mir_dataflow {
-            let res = write_graphviz_results(tcx, body, &self, &results, pass_name);
+            let res = write_graphviz_results(tcx, body, &results, pass_name);
             if let Err(e) = res {
                 error!("Failed to write graphviz dataflow results: {}", e);
             }
         }
 
-        AnalysisAndResults { analysis: self, results }
+        results
     }
 }
 

compiler/rustc_mir_dataflow/src/framework/results.rs

@@ -5,26 +5,26 @@ use rustc_middle::mir::{BasicBlock, Body};
 
 use super::{Analysis, ResultsCursor};
 
-/// The results of a dataflow analysis that has converged to fixpoint. It only holds the domain
-/// values at the entry of each basic block. Domain values in other parts of the block are
-/// recomputed on the fly by visitors (i.e. `ResultsCursor`, or `ResultsVisitor` impls).
-pub type Results<D> = IndexVec<BasicBlock, D>;
+pub type EntryStates<D> = IndexVec<BasicBlock, D>;
 
-/// Utility type used in a few places where it's convenient to bundle an analysis with its results.
-pub struct AnalysisAndResults<'tcx, A>
+/// The results of a dataflow analysis that has converged to fixpoint. It holds the domain values
+/// (states) at the entry of each basic block. Domain values in other parts of the block are
+/// recomputed on the fly by visitors (i.e. `ResultsCursor`, or `ResultsVisitor` impls). The
+/// analysis is also present because it's often needed alongside the entry states.
+pub struct Results<'tcx, A>
 where
     A: Analysis<'tcx>,
 {
     pub analysis: A,
-    pub results: Results<A::Domain>,
+    pub entry_states: EntryStates<A::Domain>,
 }
 
-impl<'tcx, A> AnalysisAndResults<'tcx, A>
+impl<'tcx, A> Results<'tcx, A>
 where
     A: Analysis<'tcx>,
 {
     /// Creates a `ResultsCursor` that takes ownership of `self`.
     pub fn into_results_cursor<'mir>(self, body: &'mir Body<'tcx>) -> ResultsCursor<'mir, 'tcx, A> {
-        ResultsCursor::new_owning(body, self.analysis, self.results)
+        ResultsCursor::new_owning(body, self)
     }
 }

compiler/rustc_mir_dataflow/src/framework/tests.rs

@@ -71,15 +71,15 @@ fn mock_body<'tcx>() -> mir::Body<'tcx> {
 ///
 /// | Location               | Before            | After  |
 /// |------------------------|-------------------|--------|
-/// | (on_entry)             | {102}                     ||
+/// | (on_entry)             | {102}             |        |
 /// | statement 0            | +0                | +1     |
 /// | statement 1            | +2                | +3     |
 /// | `Call` terminator      | +4                | +5     |
-/// | (on unwind)            | {102,0,1,2,3,4,5}         ||
+/// | (on unwind)            | {102,0,1,2,3,4,5} |        |
 ///
 /// The `102` in the block's entry set is derived from the basic block index and ensures that the
 /// expected state is unique across all basic blocks. Remember, it is generated by
-/// `mock_results`, not from actually running `MockAnalysis` to fixpoint.
+/// `mock_entry_states`, not from actually running `MockAnalysis` to fixpoint.
 struct MockAnalysis<'tcx, D> {
     body: &'tcx mir::Body<'tcx>,
     dir: PhantomData<D>,
@@ -96,7 +96,7 @@ impl<D: Direction> MockAnalysis<'_, D> {
         ret
     }
 
-    fn mock_results(&self) -> IndexVec<BasicBlock, DenseBitSet<usize>> {
+    fn mock_entry_states(&self) -> IndexVec<BasicBlock, DenseBitSet<usize>> {
         let empty = self.bottom_value(self.body);
         let mut ret = IndexVec::from_elem(empty, &self.body.basic_blocks);
 
@@ -255,7 +255,7 @@ fn test_cursor<D: Direction>(analysis: MockAnalysis<'_, D>) {
     let body = analysis.body;
 
     let mut cursor =
-        AnalysisAndResults { results: analysis.mock_results(), analysis }.into_results_cursor(body);
+        Results { entry_states: analysis.mock_entry_states(), analysis }.into_results_cursor(body);
 
     cursor.allow_unreachable();