Add a context parameter to JoinSemiLattice

Author: Jarcho

compiler/rustc_const_eval/src/transform/check_consts/resolver.rs

@@ -307,8 +307,8 @@ impl<C> DebugWithContext<C> for State {
 }
 
 impl JoinSemiLattice for State {
-    fn join(&mut self, other: &Self) -> bool {
-        self.qualif.join(&other.qualif) || self.borrow.join(&other.borrow)
+    fn join(&mut self, _: &(), other: &Self) -> bool {
+        self.qualif.union(&other.qualif) || self.borrow.union(&other.borrow)
     }
 }
 

compiler/rustc_mir_dataflow/src/framework/direction.rs

@@ -4,7 +4,8 @@ use std::ops::RangeInclusive;
 
 use super::visitor::{ResultsVisitable, ResultsVisitor};
 use super::{
-    Analysis, CallReturnPlaces, Effect, EffectIndex, GenKillAnalysis, GenKillSet, SwitchIntTarget,
+    Analysis, AnalysisDomain, CallReturnPlaces, Effect, EffectIndex, GenKillAnalysis, GenKillSet,
+    SwitchIntTarget, WithJoinCtxt,
 };
 
 pub trait Direction {
@@ -55,9 +56,9 @@ pub trait Direction {
         body: &mir::Body<'tcx>,
         exit_state: &mut A::Domain,
         block: (BasicBlock, &'_ mir::BasicBlockData<'tcx>),
-        propagate: impl FnMut(BasicBlock, &A::Domain),
+        propagate: impl FnMut(&A::JoinCtxt, BasicBlock, &A::Domain),
     ) where
-        A: Analysis<'tcx>;
+        A: Analysis<'tcx> + WithJoinCtxt<'tcx>;
 }
 
 /// Dataflow that runs from the exit of a block (the terminator), to its entry (the first statement).
@@ -221,9 +222,9 @@ impl Direction for Backward {
         body: &mir::Body<'tcx>,
         exit_state: &mut A::Domain,
         (bb, _bb_data): (BasicBlock, &'_ mir::BasicBlockData<'tcx>),
-        mut propagate: impl FnMut(BasicBlock, &A::Domain),
+        mut propagate: impl FnMut(&A::JoinCtxt, BasicBlock, &A::Domain),
     ) where
-        A: Analysis<'tcx>,
+        A: Analysis<'tcx> + WithJoinCtxt<'tcx>,
     {
         for pred in body.basic_blocks.predecessors()[bb].iter().copied() {
             match body[pred].terminator().kind {
@@ -237,7 +238,7 @@ impl Direction for Backward {
                         pred,
                         CallReturnPlaces::Call(destination),
                     );
-                    propagate(pred, &tmp);
+                    propagate(analysis.join_ctxt(), pred, &tmp);
                 }
 
                 mir::TerminatorKind::InlineAsm {
@@ -249,13 +250,13 @@ impl Direction for Backward {
                         pred,
                         CallReturnPlaces::InlineAsm(operands),
                     );
-                    propagate(pred, &tmp);
+                    propagate(analysis.join_ctxt(), pred, &tmp);
                 }
 
                 mir::TerminatorKind::Yield { resume, resume_arg, .. } if resume == bb => {
                     let mut tmp = exit_state.clone();
                     analysis.apply_yield_resume_effect(&mut tmp, resume, resume_arg);
-                    propagate(pred, &tmp);
+                    propagate(analysis.join_ctxt(), pred, &tmp);
                 }
 
                 mir::TerminatorKind::SwitchInt { targets: _, ref discr } => {
@@ -271,11 +272,11 @@ impl Direction for Backward {
                     analysis.apply_switch_int_edge_effects(pred, discr, &mut applier);
 
                     if !applier.effects_applied {
-                        propagate(pred, exit_state)
+                        propagate(analysis.join_ctxt(), pred, exit_state)
                     }
                 }
 
-                _ => propagate(pred, exit_state),
+                _ => propagate(analysis.join_ctxt(), pred, exit_state),
             }
         }
     }
@@ -290,12 +291,17 @@ struct BackwardSwitchIntEdgeEffectsApplier<'a, 'tcx, D, F> {
     effects_applied: bool,
 }
 
-impl<D, F> super::SwitchIntEdgeEffects<D> for BackwardSwitchIntEdgeEffectsApplier<'_, '_, D, F>
+impl<'tcx, A, F> super::SwitchIntEdgeEffects<'tcx, A>
+    for BackwardSwitchIntEdgeEffectsApplier<'_, '_, A::Domain, F>
 where
-    D: Clone,
-    F: FnMut(BasicBlock, &D),
+    A: AnalysisDomain<'tcx>,
+    F: FnMut(&A::JoinCtxt, BasicBlock, &A::Domain),
 {
-    fn apply(&mut self, mut apply_edge_effect: impl FnMut(&mut D, SwitchIntTarget)) {
+    fn apply(
+        &mut self,
+        ctxt: &A::JoinCtxt,
+        mut apply_edge_effect: impl FnMut(&mut A::Domain, SwitchIntTarget),
+    ) {
         assert!(!self.effects_applied);
 
         let values = &self.body.basic_blocks.switch_sources()[&(self.bb, self.pred)];
@@ -305,7 +311,7 @@ where
         for target in targets {
             let tmp = opt_clone_from_or_clone(&mut tmp, self.exit_state);
             apply_edge_effect(tmp, target);
-            (self.propagate)(self.pred, tmp);
+            (self.propagate)(ctxt, self.pred, tmp);
         }
 
         self.effects_applied = true;
@@ -468,43 +474,43 @@ impl Direction for Forward {
         _body: &mir::Body<'tcx>,
         exit_state: &mut A::Domain,
         (bb, bb_data): (BasicBlock, &'_ mir::BasicBlockData<'tcx>),
-        mut propagate: impl FnMut(BasicBlock, &A::Domain),
+        mut propagate: impl FnMut(&A::JoinCtxt, BasicBlock, &A::Domain),
     ) where
-        A: Analysis<'tcx>,
+        A: Analysis<'tcx> + WithJoinCtxt<'tcx>,
     {
         use mir::TerminatorKind::*;
         match bb_data.terminator().kind {
             Return | Resume | Terminate | GeneratorDrop | Unreachable => {}
 
-            Goto { target } => propagate(target, exit_state),
+            Goto { target } => propagate(analysis.join_ctxt(), target, exit_state),
 
             Assert { target, unwind, expected: _, msg: _, cond: _ }
             | Drop { target, unwind, place: _, replace: _ }
             | FalseUnwind { real_target: target, unwind } => {
                 if let UnwindAction::Cleanup(unwind) = unwind {
-                    propagate(unwind, exit_state);
+                    propagate(analysis.join_ctxt(), unwind, exit_state);
                 }
 
-                propagate(target, exit_state);
+                propagate(analysis.join_ctxt(), target, exit_state);
             }
 
             FalseEdge { real_target, imaginary_target } => {
-                propagate(real_target, exit_state);
-                propagate(imaginary_target, exit_state);
+                propagate(analysis.join_ctxt(), real_target, exit_state);
+                propagate(analysis.join_ctxt(), imaginary_target, exit_state);
             }
 
             Yield { resume: target, drop, resume_arg, value: _ } => {
                 if let Some(drop) = drop {
-                    propagate(drop, exit_state);
+                    propagate(analysis.join_ctxt(), drop, exit_state);
                 }
 
                 analysis.apply_yield_resume_effect(exit_state, target, resume_arg);
-                propagate(target, exit_state);
+                propagate(analysis.join_ctxt(), target, exit_state);
             }
 
             Call { unwind, destination, target, func: _, args: _, call_source: _, fn_span: _ } => {
                 if let UnwindAction::Cleanup(unwind) = unwind {
-                    propagate(unwind, exit_state);
+                    propagate(analysis.join_ctxt(), unwind, exit_state);
                 }
 
                 if let Some(target) = target {
@@ -515,7 +521,7 @@ impl Direction for Forward {
                         bb,
                         CallReturnPlaces::Call(destination),
                     );
-                    propagate(target, exit_state);
+                    propagate(analysis.join_ctxt(), target, exit_state);
                 }
             }
 
@@ -528,7 +534,7 @@ impl Direction for Forward {
                 unwind,
             } => {
                 if let UnwindAction::Cleanup(unwind) = unwind {
-                    propagate(unwind, exit_state);
+                    propagate(analysis.join_ctxt(), unwind, exit_state);
                 }
 
                 if let Some(target) = destination {
@@ -539,7 +545,7 @@ impl Direction for Forward {
                         bb,
                         CallReturnPlaces::InlineAsm(operands),
                     );
-                    propagate(target, exit_state);
+                    propagate(analysis.join_ctxt(), target, exit_state);
                 }
             }
 
@@ -562,7 +568,7 @@ impl Direction for Forward {
 
                 if !effects_applied {
                     for target in targets.all_targets() {
-                        propagate(*target, exit_state);
+                        propagate(analysis.join_ctxt(), *target, exit_state);
                     }
                 }
             }
@@ -578,26 +584,31 @@ struct ForwardSwitchIntEdgeEffectsApplier<'a, D, F> {
     effects_applied: bool,
 }
 
-impl<D, F> super::SwitchIntEdgeEffects<D> for ForwardSwitchIntEdgeEffectsApplier<'_, D, F>
+impl<'tcx, A, F> super::SwitchIntEdgeEffects<'tcx, A>
+    for ForwardSwitchIntEdgeEffectsApplier<'_, A::Domain, F>
 where
-    D: Clone,
-    F: FnMut(BasicBlock, &D),
+    A: AnalysisDomain<'tcx>,
+    F: FnMut(&A::JoinCtxt, BasicBlock, &A::Domain),
 {
-    fn apply(&mut self, mut apply_edge_effect: impl FnMut(&mut D, SwitchIntTarget)) {
+    fn apply(
+        &mut self,
+        ctxt: &A::JoinCtxt,
+        mut apply_edge_effect: impl FnMut(&mut A::Domain, SwitchIntTarget),
+    ) {
         assert!(!self.effects_applied);
 
         let mut tmp = None;
         for (value, target) in self.targets.iter() {
             let tmp = opt_clone_from_or_clone(&mut tmp, self.exit_state);
             apply_edge_effect(tmp, SwitchIntTarget { value: Some(value), target });
-            (self.propagate)(target, tmp);
+            (self.propagate)(ctxt, target, tmp);
         }
 
         // Once we get to the final, "otherwise" branch, there is no need to preserve `exit_state`,
         // so pass it directly to `apply_edge_effect` to save a clone of the dataflow state.
         let otherwise = self.targets.otherwise();
         apply_edge_effect(self.exit_state, SwitchIntTarget { value: None, target: otherwise });
-        (self.propagate)(otherwise, self.exit_state);
+        (self.propagate)(ctxt, otherwise, self.exit_state);
 
         self.effects_applied = true;
     }

compiler/rustc_mir_dataflow/src/framework/engine.rs

@@ -26,7 +26,7 @@ use super::graphviz;
 use super::{
     visit_results, Analysis, AnalysisDomain, CloneAnalysis, Direction, GenKill, GenKillAnalysis,
     GenKillSet, JoinSemiLattice, ResultsClonedCursor, ResultsCursor, ResultsRefCursor,
-    ResultsVisitor,
+    ResultsVisitor, WithJoinCtxt,
 };
 
 pub type EntrySets<'tcx, A> = IndexVec<BasicBlock, <A as AnalysisDomain<'tcx>>::Domain>;
@@ -149,8 +149,8 @@ where
 
 impl<'a, 'tcx, A, D, T> Engine<'a, 'tcx, A>
 where
-    A: GenKillAnalysis<'tcx, Idx = T, Domain = D>,
-    D: Clone + JoinSemiLattice + GenKill<T> + BitSetExt<T>,
+    A: GenKillAnalysis<'tcx, Idx = T, Domain = D> + WithJoinCtxt<'tcx>,
+    D: Clone + JoinSemiLattice<A::JoinCtxt> + GenKill<T> + BitSetExt<T>,
     T: Idx,
 {
     /// Creates a new `Engine` to solve a gen-kill dataflow problem.
@@ -183,8 +183,8 @@ where
 
 impl<'a, 'tcx, A, D> Engine<'a, 'tcx, A>
 where
-    A: Analysis<'tcx, Domain = D>,
-    D: Clone + JoinSemiLattice,
+    A: Analysis<'tcx, Domain = D> + WithJoinCtxt<'tcx>,
+    D: Clone + JoinSemiLattice<A::JoinCtxt>,
 {
     /// Creates a new `Engine` to solve a dataflow problem with an arbitrary transfer
     /// function.
@@ -276,8 +276,8 @@ where
                 body,
                 &mut state,
                 (bb, bb_data),
-                |target: BasicBlock, state: &A::Domain| {
-                    let set_changed = entry_sets[target].join(state);
+                |ctxt: &A::JoinCtxt, target: BasicBlock, state: &A::Domain| {
+                    let set_changed = entry_sets[target].join(ctxt, state);
                     if set_changed {
                         dirty_queue.insert(target);
                     }