Rollup merge of #140234 - nnethercote:separate-Analysis-and-Results, r=davidtwco

Separate dataflow analysis and results
`Analysis` gets put into `Results` with `EntryStates`, by `iterate_to_fixpoint`. This has two problems:
- `Results` is passed various places where only `Analysis` is needed.
- `EntryStates` is passed around mutably everywhere even though it is immutable.
This commit mostly separates `Analysis` from `Results` and fixes these two problems.
r? `@davidtwco`

Author: GuillaumeGomez

compiler/rustc_borrowck/src/lib.rs

@@ -47,7 +47,7 @@ use rustc_mir_dataflow::impls::{
 use rustc_mir_dataflow::move_paths::{
 InitIndex,InitLocation,LookupResult,MoveData,MovePathIndex,
 };
-use rustc_mir_dataflow::{Analysis,EntryStates,Results,ResultsVisitor, visit_results};
+use rustc_mir_dataflow::{Analysis,Results,ResultsVisitor, visit_results};
 use rustc_session::lint::builtin::{TAIL_EXPR_DROP_ORDER,UNUSED_MUT};
 use rustc_span::{ErrorGuaranteed,Span,Symbol};
 use smallvec::SmallVec;
@@ -461,11 +461,13 @@ fn do_mir_borrowck<'tcx>(
 // Compute and report region errors, if any.
  mbcx.report_region_errors(nll_errors);
 
-letmut flow_results = get_flow_results(tcx, body,&move_data,&borrow_set,&regioncx);
+let(mut flow_analysis, flow_entry_states) =
+get_flow_results(tcx, body,&move_data,&borrow_set,&regioncx);
 visit_results(
  body,
  traversal::reverse_postorder(body).map(|(bb, _)| bb),
-&mut flow_results,
+&mut flow_analysis,
+&flow_entry_states,
 &mut mbcx,
 );
 
@@ -525,7 +527,7 @@ fn get_flow_results<'a, 'tcx>(
 move_data:&'aMoveData<'tcx>,
 borrow_set:&'aBorrowSet<'tcx>,
 regioncx:&RegionInferenceContext<'tcx>,
-) -> Results<'tcx,Borrowck<'a,'tcx>>{
+) -> (Borrowck<'a,'tcx>,Results<BorrowckDomain>){
 // 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(
@@ -550,14 +552,14 @@ fn get_flow_results<'a, 'tcx>(
 ever_inits: ever_inits.analysis,
 };
 
-assert_eq!(borrows.entry_states.len(), uninits.entry_states.len());
-assert_eq!(borrows.entry_states.len(), ever_inits.entry_states.len());
-letentry_states:EntryStates<'_,Borrowck<'_,'_>> =
- itertools::izip!(borrows.entry_states, uninits.entry_states, ever_inits.entry_states)
+assert_eq!(borrows.results.len(), uninits.results.len());
+assert_eq!(borrows.results.len(), ever_inits.results.len());
+letresults:Results<_> =
+ itertools::izip!(borrows.results, uninits.results, ever_inits.results)
 .map(|(borrows, uninits, ever_inits)| BorrowckDomain{ borrows, uninits, ever_inits })
 .collect();
 
-Results{analysis,entry_states }
+(analysis,results)
 }
 
 pub(crate)structBorrowckInferCtxt<'tcx>{
@@ -705,7 +707,7 @@ struct MirBorrowckCtxt<'a, 'infcx, 'tcx> {
 impl<'a,'tcx>ResultsVisitor<'tcx,Borrowck<'a,'tcx>>forMirBorrowckCtxt<'a,'_,'tcx>{
 fnvisit_after_early_statement_effect(
 &mutself,
-_results:&mutResults<'tcx,Borrowck<'a,'tcx>>,
+_analysis:&mutBorrowck<'a,'tcx>,
 state:&BorrowckDomain,
 stmt:&Statement<'tcx>,
 location:Location,
@@ -781,7 +783,7 @@ impl<'a, 'tcx> ResultsVisitor<'tcx, Borrowck<'a, 'tcx>> for MirBorrowckCtxt<'a,
 
 fnvisit_after_early_terminator_effect(
 &mutself,
-_results:&mutResults<'tcx,Borrowck<'a,'tcx>>,
+_analysis:&mutBorrowck<'a,'tcx>,
 state:&BorrowckDomain,
 term:&Terminator<'tcx>,
 loc:Location,
@@ -901,7 +903,7 @@ impl<'a, 'tcx> ResultsVisitor<'tcx, Borrowck<'a, 'tcx>> for MirBorrowckCtxt<'a,
 
 fnvisit_after_primary_terminator_effect(
 &mutself,
-_results:&mutResults<'tcx,Borrowck<'a,'tcx>>,
+_analysis:&mutBorrowck<'a,'tcx>,
 state:&BorrowckDomain,
 term:&Terminator<'tcx>,
 loc:Location,

compiler/rustc_mir_dataflow/src/framework/cursor.rs

@@ -1,5 +1,6 @@
 //! Random access inspection of the results of a dataflow analysis.
 
+use std::borrow::Cow;
 use std::cmp::Ordering;
 use std::ops::{Deref,DerefMut};
 
@@ -9,38 +10,30 @@ use rustc_middle::mir::{self, BasicBlock, Location};
 
 usesuper::{Analysis,Direction,Effect,EffectIndex,Results};
 
-/// Some `ResultsCursor`s want to own a `Results`, and some want to borrow a `Results`, either
-/// mutable or immutably. This type allows all of the above. It's similar to `Cow`.
-pubenumResultsHandle<'a,'tcx,A>
-where
-A:Analysis<'tcx>,
-{
-BorrowedMut(&'amutResults<'tcx,A>),
-Owned(Results<'tcx,A>),
+/// 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.
+enumCowMut<'a,T>{
+BorrowedMut(&'amutT),
+Owned(T),
 }
 
-impl<'tcx,A>DerefforResultsHandle<'_,'tcx,A>
-where
-A:Analysis<'tcx>,
-{
-typeTarget = Results<'tcx,A>;
+impl<T>DerefforCowMut<'_,T>{
+typeTarget = T;
 
-fnderef(&self) -> &Results<'tcx,A>{
+fnderef(&self) -> &T{
 matchself{
-ResultsHandle::BorrowedMut(borrowed) => borrowed,
-ResultsHandle::Owned(owned) => owned,
+CowMut::BorrowedMut(borrowed) => borrowed,
+CowMut::Owned(owned) => owned,
 }
 }
 }
 
-impl<'tcx,A>DerefMutforResultsHandle<'_,'tcx,A>
-where
-A:Analysis<'tcx>,
-{
-fnderef_mut(&mutself) -> &mutResults<'tcx,A>{
+impl<T>DerefMutforCowMut<'_,T>{
+fnderef_mut(&mutself) -> &mutT{
 matchself{
-ResultsHandle::BorrowedMut(borrowed) => borrowed,
-ResultsHandle::Owned(owned) => owned,
+CowMut::BorrowedMut(borrowed) => borrowed,
+CowMut::Owned(owned) => owned,
 }
 }
 }
@@ -60,7 +53,8 @@ where
 A:Analysis<'tcx>,
 {
 body:&'mir mir::Body<'tcx>,
-results:ResultsHandle<'mir,'tcx,A>,
+analysis:CowMut<'mir,A>,
+results:Cow<'mir,Results<A::Domain>>,
 state:A::Domain,
 
 pos:CursorPosition,
@@ -88,11 +82,15 @@ where
 self.body
 }
 
-/// Returns a new cursor that can inspect `results`.
-pubfnnew(body:&'mir mir::Body<'tcx>,results:ResultsHandle<'mir,'tcx,A>) -> Self{
-let bottom_value = results.analysis.bottom_value(body);
+fnnew(
+body:&'mir mir::Body<'tcx>,
+analysis:CowMut<'mir,A>,
+results:Cow<'mir,Results<A::Domain>>,
+) -> Self{
+let bottom_value = analysis.bottom_value(body);
 ResultsCursor{
  body,
+ analysis,
  results,
 
 // Initialize to the `bottom_value` and set `state_needs_reset` to tell the cursor that
@@ -107,6 +105,24 @@ where
 }
 }
 
+/// Returns a new cursor that takes ownership of and inspects analysis results.
+pubfnnew_owning(
+body:&'mir mir::Body<'tcx>,
+analysis:A,
+results:Results<A::Domain>,
+) -> Self{
+Self::new(body,CowMut::Owned(analysis),Cow::Owned(results))
+}
+
+/// Returns a new cursor that borrows and inspects analysis results.
+pubfnnew_borrowing(
+body:&'mir mir::Body<'tcx>,
+analysis:&'mirmutA,
+results:&'mirResults<A::Domain>,
+) -> Self{
+Self::new(body,CowMut::BorrowedMut(analysis),Cow::Borrowed(results))
+}
+
 /// Allows inspection of unreachable basic blocks even with `debug_assertions` enabled.
 #[cfg(test)]
 pub(crate)fnallow_unreachable(&mutself){
@@ -116,7 +132,7 @@ where
 
 /// Returns the `Analysis` used to generate the underlying `Results`.
 pubfnanalysis(&self) -> &A{
-&self.results.analysis
+&self.analysis
 }
 
 /// Resets the cursor to hold the entry set for the given basic block.
@@ -128,7 +144,7 @@ where
 #[cfg(debug_assertions)]
 assert!(self.reachable_blocks.contains(block));
 
-self.state.clone_from(self.results.entry_set_for_block(block));
+self.state.clone_from(&self.results[block]);
 self.pos = CursorPosition::block_entry(block);
 self.state_needs_reset = false;
 }
@@ -220,7 +236,7 @@ where
 let target_effect_index = effect.at_index(target.statement_index);
 
 A::Direction::apply_effects_in_range(
-&mutself.results.analysis,
+&mut*self.analysis,
 &mutself.state,
  target.block,
  block_data,
@@ -236,7 +252,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.
 pubfnapply_custom_effect(&mutself,f:implFnOnce(&mutA,&mutA::Domain)){
-f(&mutself.results.analysis,&mutself.state);
+f(&mutself.analysis,&mutself.state);
 self.state_needs_reset = true;
 }
 }

compiler/rustc_mir_dataflow/src/framework/direction.rs

@@ -5,7 +5,7 @@ use rustc_middle::mir::{
 };
 
 usesuper::visitor::ResultsVisitor;
-usesuper::{Analysis,Effect,EffectIndex,Results};
+usesuper::{Analysis,Effect,EffectIndex};
 
 pubtraitDirection{
 constIS_FORWARD:bool;
@@ -36,13 +36,13 @@ pub trait Direction {
 A:Analysis<'tcx>;
 
 /// Called by `ResultsVisitor` to recompute the analysis domain values for
-/// all locations in a basic block (starting from the entry value stored
-/// in `Results`) and to visit them with `vis`.
+/// all locations in a basic block (starting from `entry_state` and to
+/// visit them with `vis`.
 fnvisit_results_in_block<'mir,'tcx,A>(
 state:&mutA::Domain,
 block:BasicBlock,
 block_data:&'mir mir::BasicBlockData<'tcx>,
-results:&mutResults<'tcx,A>,
+analysis:&mutA,
 vis:&mutimplResultsVisitor<'tcx,A>,
 )where
 A:Analysis<'tcx>;
@@ -211,28 +211,26 @@ impl Direction for Backward {
 state:&mutA::Domain,
 block:BasicBlock,
 block_data:&'mir mir::BasicBlockData<'tcx>,
-results:&mutResults<'tcx,A>,
+analysis:&mutA,
 vis:&mutimplResultsVisitor<'tcx,A>,
 )where
 A:Analysis<'tcx>,
 {
- state.clone_from(results.entry_set_for_block(block));
-
  vis.visit_block_end(state);
 
 let loc = Location{ block,statement_index: block_data.statements.len()};
 let term = block_data.terminator();
-results.analysis.apply_early_terminator_effect(state, term, loc);
- vis.visit_after_early_terminator_effect(results, state, term, loc);
-results.analysis.apply_primary_terminator_effect(state, term, loc);
- vis.visit_after_primary_terminator_effect(results, state, term, loc);
+ analysis.apply_early_terminator_effect(state, term, loc);
+ vis.visit_after_early_terminator_effect(analysis, state, term, loc);
+ analysis.apply_primary_terminator_effect(state, term, loc);
+ vis.visit_after_primary_terminator_effect(analysis, state, term, loc);
 
 for(statement_index, stmt)in block_data.statements.iter().enumerate().rev(){
 let loc = Location{ block, statement_index };
-results.analysis.apply_early_statement_effect(state, stmt, loc);
- vis.visit_after_early_statement_effect(results, state, stmt, loc);
-results.analysis.apply_primary_statement_effect(state, stmt, loc);
- vis.visit_after_primary_statement_effect(results, state, stmt, loc);
+ analysis.apply_early_statement_effect(state, stmt, loc);
+ vis.visit_after_early_statement_effect(analysis, state, stmt, loc);
+ analysis.apply_primary_statement_effect(state, stmt, loc);
+ vis.visit_after_primary_statement_effect(analysis, state, stmt, loc);
 }
 
  vis.visit_block_start(state);
@@ -393,29 +391,27 @@ impl Direction for Forward {
 state:&mutA::Domain,
 block:BasicBlock,
 block_data:&'mir mir::BasicBlockData<'tcx>,
-results:&mutResults<'tcx,A>,
+analysis:&mutA,
 vis:&mutimplResultsVisitor<'tcx,A>,
 )where
 A:Analysis<'tcx>,
 {
- state.clone_from(results.entry_set_for_block(block));
-
  vis.visit_block_start(state);
 
 for(statement_index, stmt)in block_data.statements.iter().enumerate(){
 let loc = Location{ block, statement_index };
-results.analysis.apply_early_statement_effect(state, stmt, loc);
- vis.visit_after_early_statement_effect(results, state, stmt, loc);
-results.analysis.apply_primary_statement_effect(state, stmt, loc);
- vis.visit_after_primary_statement_effect(results, state, stmt, loc);
+ analysis.apply_early_statement_effect(state, stmt, loc);
+ vis.visit_after_early_statement_effect(analysis, state, stmt, loc);
+ analysis.apply_primary_statement_effect(state, stmt, loc);
+ vis.visit_after_primary_statement_effect(analysis, state, stmt, loc);
 }
 
 let loc = Location{ block,statement_index: block_data.statements.len()};
 let term = block_data.terminator();
-results.analysis.apply_early_terminator_effect(state, term, loc);
- vis.visit_after_early_terminator_effect(results, state, term, loc);
-results.analysis.apply_primary_terminator_effect(state, term, loc);
- vis.visit_after_primary_terminator_effect(results, state, term, loc);
+ analysis.apply_early_terminator_effect(state, term, loc);
+ vis.visit_after_early_terminator_effect(analysis, state, term, loc);
+ analysis.apply_primary_terminator_effect(state, term, loc);
+ vis.visit_after_primary_terminator_effect(analysis, state, term, loc);
 
  vis.visit_block_end(state);
 }