Make Analysis immutable in many more places.

The `state: A::Domain` value is the primary things that's modified when
performing an analysis. The `Analysis` impl is immutable in every case
but one (`MaybeRequiredStorage`) and it now uses interior mutability.

As well as changing many `&mut A` arguments to `&A`, this also:
- lets `CowMut` be replaced with the simpler `SimpleCow` in `cursor.rs`;
- removes the need for the `RefCell` in `Formatter`;
- removes the need for `MaybeBorrowedLocals` to impl `Clone`, because
  it's a unit type and it's now clear that its constructor can be used
  directly instead of being put into a local variable and cloned.

Author: nnethercote

compiler/rustc_borrowck/src/dataflow.rs

@@ -44,7 +44,7 @@ impl<'a, 'tcx> Analysis<'tcx> for Borrowck<'a, 'tcx> {
     }
 
     fn apply_early_statement_effect(
-        &mut self,
+        &self,
         state: &mut Self::Domain,
         stmt: &mir::Statement<'tcx>,
         loc: Location,
@@ -55,7 +55,7 @@ impl<'a, 'tcx> Analysis<'tcx> for Borrowck<'a, 'tcx> {
     }
 
     fn apply_primary_statement_effect(
-        &mut self,
+        &self,
         state: &mut Self::Domain,
         stmt: &mir::Statement<'tcx>,
         loc: Location,
@@ -66,7 +66,7 @@ impl<'a, 'tcx> Analysis<'tcx> for Borrowck<'a, 'tcx> {
     }
 
     fn apply_early_terminator_effect(
-        &mut self,
+        &self,
         state: &mut Self::Domain,
         term: &mir::Terminator<'tcx>,
         loc: Location,
@@ -77,7 +77,7 @@ impl<'a, 'tcx> Analysis<'tcx> for Borrowck<'a, 'tcx> {
     }
 
     fn apply_primary_terminator_effect<'mir>(
-        &mut self,
+        &self,
         state: &mut Self::Domain,
         term: &'mir mir::Terminator<'tcx>,
         loc: Location,
@@ -92,7 +92,7 @@ impl<'a, 'tcx> Analysis<'tcx> for Borrowck<'a, 'tcx> {
     }
 
     fn apply_call_return_effect(
-        &mut self,
+        &self,
         _state: &mut Self::Domain,
         _block: BasicBlock,
         _return_places: CallReturnPlaces<'_, 'tcx>,
@@ -533,7 +533,7 @@ impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for Borrows<'_, 'tcx> {
     }
 
     fn apply_early_statement_effect(
-        &mut self,
+        &self,
         state: &mut Self::Domain,
         _statement: &mir::Statement<'tcx>,
         location: Location,
@@ -542,7 +542,7 @@ impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for Borrows<'_, 'tcx> {
     }
 
     fn apply_primary_statement_effect(
-        &mut self,
+        &self,
         state: &mut Self::Domain,
         stmt: &mir::Statement<'tcx>,
         location: Location,
@@ -590,7 +590,7 @@ impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for Borrows<'_, 'tcx> {
     }
 
     fn apply_early_terminator_effect(
-        &mut self,
+        &self,
         state: &mut Self::Domain,
         _terminator: &mir::Terminator<'tcx>,
         location: Location,
@@ -599,7 +599,7 @@ impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for Borrows<'_, 'tcx> {
     }
 
     fn apply_primary_terminator_effect<'mir>(
-        &mut self,
+        &self,
         state: &mut Self::Domain,
         terminator: &'mir mir::Terminator<'tcx>,
         _location: Location,

compiler/rustc_borrowck/src/lib.rs

@@ -537,13 +537,13 @@ fn borrowck_check_region_constraints<'tcx>(
         mbcx.report_region_errors(nll_errors);
     }
 
-    let (mut flow_analysis, flow_entry_states) =
+    let (flow_analysis, flow_results) =
         get_flow_results(tcx, body, &move_data, &borrow_set, &regioncx);
     visit_results(
         body,
         traversal::reverse_postorder(body).map(|(bb, _)| bb),
-        &mut flow_analysis,
-        &flow_entry_states,
+        &flow_analysis,
+        &flow_results,
         &mut mbcx,
     );
 

compiler/rustc_const_eval/src/check_consts/resolver.rs

@@ -332,7 +332,7 @@ where
     }
 
     fn apply_primary_statement_effect(
-        &mut self,
+        &self,
         state: &mut Self::Domain,
         statement: &mir::Statement<'tcx>,
         location: Location,
@@ -341,7 +341,7 @@ where
     }
 
     fn apply_primary_terminator_effect<'mir>(
-        &mut self,
+        &self,
         state: &mut Self::Domain,
         terminator: &'mir mir::Terminator<'tcx>,
         location: Location,
@@ -351,7 +351,7 @@ where
     }
 
     fn apply_call_return_effect(
-        &mut self,
+        &self,
         state: &mut Self::Domain,
         block: BasicBlock,
         return_places: CallReturnPlaces<'_, 'tcx>,

compiler/rustc_mir_dataflow/src/framework/cursor.rs

@@ -1,39 +1,28 @@
 //! Random access inspection of the results of a dataflow analysis.
 
-use std::borrow::Cow;
 use std::cmp::Ordering;
-use std::ops::{Deref, DerefMut};
+use std::ops::Deref;
 
 #[cfg(debug_assertions)]
 use rustc_index::bit_set::DenseBitSet;
 use rustc_middle::mir::{self, BasicBlock, Location};
 
 use super::{Analysis, Direction, Effect, EffectIndex, Results};
 
-/// Some `ResultsCursor`s want to own an `Analysis`, and some want to borrow an `Analysis`, either
-/// mutable or immutably. This type allows all of the above. It's similar to `Cow`, but `Cow`
-/// doesn't allow mutable borrowing.
-enum CowMut<'a, T> {
-    BorrowedMut(&'a mut T),
+/// This is like `Cow`, but it lacks the `T: ToOwned` bound and doesn't support
+/// `to_owned`/`into_owned`.
+enum SimpleCow<'a, T> {
+    Borrowed(&'a T),
     Owned(T),
 }
 
-impl<T> Deref for CowMut<'_, T> {
+impl<T> Deref for SimpleCow<'_, T> {
     type Target = T;
 
     fn deref(&self) -> &T {
         match self {
-            CowMut::BorrowedMut(borrowed) => borrowed,
-            CowMut::Owned(owned) => owned,
-        }
-    }
-}
-
-impl<T> DerefMut for CowMut<'_, T> {
-    fn deref_mut(&mut self) -> &mut T {
-        match self {
-            CowMut::BorrowedMut(borrowed) => borrowed,
-            CowMut::Owned(owned) => owned,
+            SimpleCow::Borrowed(borrowed) => borrowed,
+            SimpleCow::Owned(owned) => owned,
         }
     }
 }
@@ -53,8 +42,8 @@ where
     A: Analysis<'tcx>,
 {
     body: &'mir mir::Body<'tcx>,
-    analysis: CowMut<'mir, A>,
-    results: Cow<'mir, Results<A::Domain>>,
+    analysis: SimpleCow<'mir, A>,
+    results: SimpleCow<'mir, Results<A::Domain>>,
     state: A::Domain,
 
     pos: CursorPosition,
@@ -84,8 +73,8 @@ where
 
     fn new(
         body: &'mir mir::Body<'tcx>,
-        analysis: CowMut<'mir, A>,
-        results: Cow<'mir, Results<A::Domain>>,
+        analysis: SimpleCow<'mir, A>,
+        results: SimpleCow<'mir, Results<A::Domain>>,
     ) -> Self {
         let bottom_value = analysis.bottom_value(body);
         ResultsCursor {
@@ -111,16 +100,16 @@ where
         analysis: A,
         results: Results<A::Domain>,
     ) -> Self {
-        Self::new(body, CowMut::Owned(analysis), Cow::Owned(results))
+        Self::new(body, SimpleCow::Owned(analysis), SimpleCow::Owned(results))
     }
 
     /// Returns a new cursor that borrows and inspects analysis results.
     pub fn new_borrowing(
         body: &'mir mir::Body<'tcx>,
-        analysis: &'mir mut A,
+        analysis: &'mir A,
         results: &'mir Results<A::Domain>,
     ) -> Self {
-        Self::new(body, CowMut::BorrowedMut(analysis), Cow::Borrowed(results))
+        Self::new(body, SimpleCow::Borrowed(analysis), SimpleCow::Borrowed(results))
     }
 
     /// Allows inspection of unreachable basic blocks even with `debug_assertions` enabled.
@@ -236,7 +225,7 @@ where
         let target_effect_index = effect.at_index(target.statement_index);
 
         A::Direction::apply_effects_in_range(
-            &mut *self.analysis,
+            &*self.analysis,
             &mut self.state,
             target.block,
             block_data,
@@ -251,8 +240,8 @@ 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(&mut A, &mut A::Domain)) {
-        f(&mut self.analysis, &mut self.state);
+    pub fn apply_custom_effect(&mut self, f: impl FnOnce(&A, &mut A::Domain)) {
+        f(&self.analysis, &mut self.state);
         self.state_needs_reset = true;
     }
 }

compiler/rustc_mir_dataflow/src/framework/direction.rs

@@ -14,7 +14,7 @@ pub trait Direction {
 
     /// Called by `iterate_to_fixpoint` during initial analysis computation.
     fn apply_effects_in_block<'mir, 'tcx, A>(
-        analysis: &mut A,
+        analysis: &A,
         body: &mir::Body<'tcx>,
         state: &mut A::Domain,
         block: BasicBlock,
@@ -28,7 +28,7 @@ pub trait Direction {
     ///
     /// `effects.start()` must precede or equal `effects.end()` in this direction.
     fn apply_effects_in_range<'tcx, A>(
-        analysis: &mut A,
+        analysis: &A,
         state: &mut A::Domain,
         block: BasicBlock,
         block_data: &mir::BasicBlockData<'tcx>,
@@ -40,7 +40,7 @@ pub trait Direction {
     /// all locations in a basic block (starting from `entry_state` and to
     /// visit them with `vis`.
     fn visit_results_in_block<'mir, 'tcx, A>(
-        analysis: &mut A,
+        analysis: &A,
         state: &mut A::Domain,
         block: BasicBlock,
         block_data: &'mir mir::BasicBlockData<'tcx>,
@@ -56,7 +56,7 @@ impl Direction for Backward {
     const IS_FORWARD: bool = false;
 
     fn apply_effects_in_block<'mir, 'tcx, A>(
-        analysis: &mut A,
+        analysis: &A,
         body: &mir::Body<'tcx>,
         state: &mut A::Domain,
         block: BasicBlock,
@@ -129,7 +129,7 @@ impl Direction for Backward {
     }
 
     fn apply_effects_in_range<'tcx, A>(
-        analysis: &mut A,
+        analysis: &A,
         state: &mut A::Domain,
         block: BasicBlock,
         block_data: &mir::BasicBlockData<'tcx>,
@@ -206,7 +206,7 @@ impl Direction for Backward {
     }
 
     fn visit_results_in_block<'mir, 'tcx, A>(
-        analysis: &mut A,
+        analysis: &A,
         state: &mut A::Domain,
         block: BasicBlock,
         block_data: &'mir mir::BasicBlockData<'tcx>,
@@ -242,7 +242,7 @@ impl Direction for Forward {
     const IS_FORWARD: bool = true;
 
     fn apply_effects_in_block<'mir, 'tcx, A>(
-        analysis: &mut A,
+        analysis: &A,
         body: &mir::Body<'tcx>,
         state: &mut A::Domain,
         block: BasicBlock,
@@ -312,7 +312,7 @@ impl Direction for Forward {
     }
 
     fn apply_effects_in_range<'tcx, A>(
-        analysis: &mut A,
+        analysis: &A,
         state: &mut A::Domain,
         block: BasicBlock,
         block_data: &mir::BasicBlockData<'tcx>,
@@ -386,7 +386,7 @@ impl Direction for Forward {
     }
 
     fn visit_results_in_block<'mir, 'tcx, A>(
-        analysis: &mut A,
+        analysis: &A,
         state: &mut A::Domain,
         block: BasicBlock,
         block_data: &'mir mir::BasicBlockData<'tcx>,

compiler/rustc_mir_dataflow/src/framework/graphviz.rs

@@ -1,7 +1,6 @@
 //! A helpful diagram for debugging dataflow problems.
 
 use std::borrow::Cow;
-use std::cell::RefCell;
 use std::ffi::OsString;
 use std::path::PathBuf;
 use std::sync::OnceLock;
@@ -33,7 +32,7 @@ use crate::errors::{
 pub(super) fn write_graphviz_results<'tcx, A>(
     tcx: TyCtxt<'tcx>,
     body: &Body<'tcx>,
-    analysis: &mut A,
+    analysis: &A,
     results: &Results<A::Domain>,
     pass_name: Option<&'static str>,
 ) -> std::io::Result<()>
@@ -206,11 +205,7 @@ where
     A: Analysis<'tcx>,
 {
     body: &'mir Body<'tcx>,
-    // The `RefCell` is used because `<Formatter as Labeller>::node_label`
-    // takes `&self`, but it needs to modify the analysis. This is also the
-    // reason for the `Formatter`/`BlockFormatter` split; `BlockFormatter` has
-    // the operations that involve the mutation, i.e. within the `borrow_mut`.
-    analysis: RefCell<&'mir mut A>,
+    analysis: &'mir A,
     results: &'mir Results<A::Domain>,
     style: OutputStyle,
     reachable: DenseBitSet<BasicBlock>,
@@ -222,12 +217,12 @@ where
 {
     fn new(
         body: &'mir Body<'tcx>,
-        analysis: &'mir mut A,
+        analysis: &'mir A,
         results: &'mir Results<A::Domain>,
         style: OutputStyle,
     ) -> Self {
         let reachable = traversal::reachable_as_bitset(body);
-        Formatter { body, analysis: analysis.into(), results, style, reachable }
+        Formatter { body, analysis, results, style, reachable }
     }
 }
 
@@ -265,12 +260,11 @@ where
     }
 
     fn node_label(&self, block: &Self::Node) -> dot::LabelText<'_> {
-        let analysis = &mut **self.analysis.borrow_mut();
-
-        let diffs = StateDiffCollector::run(self.body, *block, analysis, self.results, self.style);
+        let diffs =
+            StateDiffCollector::run(self.body, *block, self.analysis, self.results, self.style);
 
         let mut fmt = BlockFormatter {
-            cursor: ResultsCursor::new_borrowing(self.body, analysis, self.results),
+            cursor: ResultsCursor::new_borrowing(self.body, self.analysis, self.results),
             style: self.style,
             bg: Background::Light,
         };
@@ -698,7 +692,7 @@ impl<D> StateDiffCollector<D> {
     fn run<'tcx, A>(
         body: &Body<'tcx>,
         block: BasicBlock,
-        analysis: &mut A,
+        analysis: &A,
         results: &Results<A::Domain>,
         style: OutputStyle,
     ) -> Self