Rename: IRAfterPass -> PostPassStatus

Also rename variants accordingly:
IRAfterPass::Changed -> PostPassStatus::IRChanged
IRAfterPass::Unchanged -> PostPassStatus::IRUnchanged

Signed-off-by: Tomas Fabrizio Orsi <[email protected]>

Author: lima-limon-inc

dialects/hir/src/transforms/spill.rs

@@ -3,7 +3,7 @@ use alloc::rc::Rc;
 use midenc_hir::{
     adt::SmallDenseMap,
     dialects::builtin::{Function, FunctionRef, LocalVariable},
-    pass::{pass::PassIdentifier, IRAfterPass, Pass, PassExecutionState},
+    pass::{pass::PassIdentifier, Pass, PassExecutionState, PostPassStatus},
     BlockRef, BuilderExt, EntityMut, Op, OpBuilder, OperationName, OperationRef, Report, Rewriter,
     SourceSpan, Spanned, Symbol, ValueRef,
 };
@@ -35,22 +35,22 @@ impl Pass for TransformSpills {
         &mut self,
         op: EntityMut<'_, Self::Target>,
         state: &mut PassExecutionState,
-    ) -> Result<IRAfterPass, Report> {
+    ) -> Result<PostPassStatus, Report> {
         let function = op.into_entity_ref();
         log::debug!(target: "insert-spills", "computing and inserting spills for {}", function.as_operation());
 
         if function.is_declaration() {
             log::debug!(target: "insert-spills", "function has no body, no spills needed!");
             state.preserved_analyses_mut().preserve_all();
-            return Ok(IRAfterPass::Unchanged);
+            return Ok(PostPassStatus::IRUnchanged);
         }
         let mut analysis =
             state.analysis_manager().get_analysis_for::<SpillAnalysis, Function>()?;
 
         if !analysis.has_spills() {
             log::debug!(target: "insert-spills", "no spills needed!");
             state.preserved_analyses_mut().preserve_all();
-            return Ok(IRAfterPass::Unchanged);
+            return Ok(PostPassStatus::IRUnchanged);
         }
 
         // Take ownership of the spills analysis so that we can mutate the analysis state during

dialects/scf/src/transforms/cfg_to_scf.rs

@@ -7,7 +7,7 @@ use midenc_hir::{
     diagnostics::Severity,
     dialects::builtin,
     dominance::DominanceInfo,
-    pass::{pass::PassIdentifier, IRAfterPass, Pass, PassExecutionState},
+    pass::{pass::PassIdentifier, Pass, PassExecutionState, PostPassStatus},
     Builder, EntityMut, Forward, Op, Operation, OperationName, OperationRef, RawWalk, Report,
     SmallVec, Spanned, Type, ValueRange, ValueRef, WalkResult,
 };
@@ -55,7 +55,7 @@ impl Pass for LiftControlFlowToSCF {
         &mut self,
         op: EntityMut<'_, Self::Target>,
         state: &mut PassExecutionState,
-    ) -> Result<IRAfterPass, Report> {
+    ) -> Result<PostPassStatus, Report> {
         let mut transformation = ControlFlowToSCFTransformation;
         let mut changed = false;
 
@@ -134,7 +134,7 @@ impl Pass for LiftControlFlowToSCF {
         });
 
         if result.was_interrupted() {
-            return result.into_result().map(|_| IRAfterPass::Unchanged);
+            return result.into_result().map(|_| PostPassStatus::IRUnchanged);
         }
 
         log::debug!(

hir-transform/src/canonicalization.rs

@@ -1,7 +1,7 @@
 use alloc::{boxed::Box, format, rc::Rc};
 
 use midenc_hir::{
-    pass::{pass::PassIdentifier, IRAfterPass, OperationPass, Pass, PassExecutionState},
+    pass::{pass::PassIdentifier, OperationPass, Pass, PassExecutionState, PostPassStatus},
     patterns::{self, FrozenRewritePatternSet, GreedyRewriteConfig, RewritePatternSet},
     Context, EntityMut, Operation, OperationName, Report, Spanned,
 };
@@ -97,10 +97,10 @@ impl Pass for Canonicalizer {
         &mut self,
         op: EntityMut<'_, Self::Target>,
         state: &mut PassExecutionState,
-    ) -> Result<IRAfterPass, Report> {
+    ) -> Result<PostPassStatus, Report> {
         let Some(rewrites) = self.rewrites.as_ref() else {
             log::debug!("skipping canonicalization as there are no rewrite patterns to apply");
-            return Ok(IRAfterPass::Unchanged);
+            return Ok(PostPassStatus::IRUnchanged);
         };
         let op = {
             let ptr = op.as_operation_ref();

hir-transform/src/sccp.rs

@@ -1,5 +1,5 @@
 use midenc_hir::{
-    pass::{pass::PassIdentifier, IRAfterPass, Pass, PassExecutionState},
+    pass::{pass::PassIdentifier, Pass, PassExecutionState, PostPassStatus},
     patterns::NoopRewriterListener,
     BlockRef, Builder, EntityMut, OpBuilder, Operation, OperationFolder, OperationName, RegionList,
     Report, SmallVec, ValueRef,
@@ -42,7 +42,7 @@ impl Pass for SparseConditionalConstantPropagation {
         &mut self,
         mut op: EntityMut<'_, Self::Target>,
         state: &mut PassExecutionState,
-    ) -> Result<IRAfterPass, Report> {
+    ) -> Result<PostPassStatus, Report> {
         // Run sparse constant propagation + dead code analysis
         let mut solver = DataFlowSolver::default();
         solver.load::<DeadCodeAnalysis>();
@@ -62,7 +62,7 @@ impl SparseConditionalConstantPropagation {
         op: &mut Operation,
         _state: &mut PassExecutionState,
         solver: &DataFlowSolver,
-    ) -> Result<IRAfterPass, Report> {
+    ) -> Result<PostPassStatus, Report> {
         let mut worklist = SmallVec::<[BlockRef; 8]>::default();
 
         let add_to_worklist = |regions: &RegionList, worklist: &mut SmallVec<[BlockRef; 8]>| {

hir-transform/src/sink.rs

@@ -4,7 +4,7 @@ use midenc_hir::{
     adt::SmallDenseMap,
     dominance::DominanceInfo,
     matchers::{self, Matcher},
-    pass::{pass::PassIdentifier, IRAfterPass, Pass, PassExecutionState},
+    pass::{pass::PassIdentifier, Pass, PassExecutionState, PostPassStatus},
     traits::{ConstantLike, Terminator},
     Backward, Builder, EntityMut, Forward, FxHashSet, OpBuilder, Operation, OperationName,
     OperationRef, ProgramPoint, RawWalk, Region, RegionBranchOpInterface,
@@ -100,7 +100,7 @@ impl Pass for ControlFlowSink {
         &mut self,
         op: EntityMut<'_, Self::Target>,
         state: &mut PassExecutionState,
-    ) -> Result<IRAfterPass, Report> {
+    ) -> Result<PostPassStatus, Report> {
         let op = op.into_entity_ref();
         log::debug!(target: "control-flow-sink", "sinking operations in {op}");
 
@@ -109,7 +109,7 @@ impl Pass for ControlFlowSink {
 
         let dominfo = state.analysis_manager().get_analysis::<DominanceInfo>()?;
 
-        let mut sunk = IRAfterPass::Unchanged;
+        let mut sunk = PostPassStatus::IRUnchanged;
         operation.raw_prewalk_all::<Forward, _>(|op: OperationRef| {
             let regions_to_sink = {
                 let op = op.borrow();
@@ -181,7 +181,7 @@ impl Pass for SinkOperandDefs {
         &mut self,
         op: EntityMut<'_, Self::Target>,
         _state: &mut PassExecutionState,
-    ) -> Result<IRAfterPass, Report> {
+    ) -> Result<PostPassStatus, Report> {
         let operation = op.as_operation_ref();
         drop(op);
 
@@ -193,7 +193,7 @@ impl Pass for SinkOperandDefs {
         // then process the worklist, moving everything into position.
         let mut worklist = alloc::collections::VecDeque::default();
 
-        let mut changed = IRAfterPass::Unchanged;
+        let mut changed = PostPassStatus::IRUnchanged;
         // Visit ops in "true" post-order (i.e. block bodies are visited bottom-up).
         operation.raw_postwalk_all::<Backward, _>(|operation: OperationRef| {
             // Determine if any of this operation's operands represent one of the following:
@@ -318,7 +318,7 @@ impl Pass for SinkOperandDefs {
                         log::trace!(target: "sink-operand-defs", "    rewriting operand {operand_value} as {replacement}");
                         operand.borrow_mut().set(replacement);
 
-                        changed = IRAfterPass::Changed;
+                        changed = PostPassStatus::IRChanged;
                         // If no other uses of this value remain, then remove the original
                         // operation, as it is now dead.
                         if !operand_value.borrow().is_used() {
@@ -365,7 +365,7 @@ impl Pass for SinkOperandDefs {
                         log::trace!(target: "sink-operand-defs", "    rewriting operand {operand_value} as {replacement}");
                         sink_state.replacements.insert(operand_value, replacement);
                         operand.borrow_mut().set(replacement);
-                        changed = IRAfterPass::Changed;
+                        changed = PostPassStatus::IRChanged;
                     } else {
                         log::trace!(target: "sink-operand-defs", "    defining op is a constant with no other uses, moving into place");
                         // The original op can be moved
@@ -560,7 +560,7 @@ pub fn control_flow_sink<P, F>(
     dominfo: &DominanceInfo,
     should_move_into_region: P,
     move_into_region: F,
-) -> IRAfterPass
+) -> PostPassStatus
 where
     P: Fn(&Operation, &Region) -> bool,
     F: Fn(OperationRef, RegionRef),

hir-transform/src/spill.rs

@@ -4,7 +4,7 @@ use midenc_hir::{
     adt::{SmallDenseMap, SmallSet},
     cfg::Graph,
     dominance::{DomTreeNode, DominanceFrontier, DominanceInfo},
-    pass::{AnalysisManager, IRAfterPass},
+    pass::{AnalysisManager, PostPassStatus},
     traits::SingleRegion,
     BlockRef, Builder, Context, FxHashMap, OpBuilder, OpOperand, Operation, OperationRef,
     ProgramPoint, Region, RegionBranchOpInterface, RegionBranchPoint, RegionRef, Report, Rewriter,
@@ -113,7 +113,7 @@ pub fn transform_spills(
     analysis: &mut SpillAnalysis,
     interface: &mut dyn TransformSpillsInterface,
     analysis_manager: AnalysisManager,
-) -> Result<IRAfterPass, Report> {
+) -> Result<PostPassStatus, Report> {
     assert!(
         op.borrow().implements::<dyn SingleRegion>(),
         "the spills transformation is not supported when the root op is multi-region"
@@ -252,7 +252,7 @@ pub fn transform_spills(
         )?;
     }
 
-    Ok(IRAfterPass::Changed)
+    Ok(PostPassStatus::IRChanged)
 }
 
 fn rewrite_single_block_spills(

hir/src/pass.rs

@@ -12,7 +12,7 @@ pub use self::{
     analysis::{Analysis, AnalysisManager, OperationAnalysis, PreservedAnalyses},
     instrumentation::{PassInstrumentation, PassInstrumentor, PipelineParentInfo},
     manager::{IRPrintingConfig, Nesting, OpPassManager, PassDisplayMode, PassManager},
-    pass::{IRAfterPass, OperationPass, Pass, PassExecutionState, PassIdentifier},
+    pass::{OperationPass, Pass, PassExecutionState, PassIdentifier, PostPassStatus},
     registry::{PassInfo, PassPipelineInfo},
     specialization::PassTarget,
     statistics::{PassStatistic, Statistic, StatisticValue},
@@ -174,12 +174,12 @@ impl Print {
         }
     }
 
-    fn should_print(&self, pass: &dyn OperationPass, ir_changed: IRAfterPass) -> bool {
+    fn should_print(&self, pass: &dyn OperationPass, ir_changed: PostPassStatus) -> bool {
         let pass_filter = self.pass_filter(pass);
 
         // Always print, unless "only_when_modified" has been set and there have not been changes.
         let modification_filter =
-            !matches!((self.only_when_modified, ir_changed), (true, IRAfterPass::Unchanged));
+            !matches!((self.only_when_modified, ir_changed), (true, PostPassStatus::IRUnchanged));
 
         pass_filter && modification_filter
     }
@@ -216,7 +216,7 @@ impl PassInstrumentation for Print {
         &mut self,
         pass: &dyn OperationPass,
         op: &OperationRef,
-        changed: IRAfterPass,
+        changed: PostPassStatus,
     ) {
         if self.should_print(pass, changed) {
             log::trace!("After the {} pass", pass.name());

hir/src/pass/instrumentation.rs

@@ -5,7 +5,7 @@ use compact_str::CompactString;
 use smallvec::SmallVec;
 
 use super::OperationPass;
-use crate::{pass::IRAfterPass, OperationName, OperationRef};
+use crate::{pass::PostPassStatus, OperationName, OperationRef};
 
 #[allow(unused_variables)]
 pub trait PassInstrumentation {
@@ -27,7 +27,7 @@ pub trait PassInstrumentation {
         &mut self,
         pass: &dyn OperationPass,
         op: &OperationRef,
-        changed: IRAfterPass,
+        changed: PostPassStatus,
     ) {
     }
     fn run_after_pass_failed(&mut self, pass: &dyn OperationPass, op: &OperationRef) {}
@@ -66,7 +66,7 @@ impl<P: ?Sized + PassInstrumentation> PassInstrumentation for Box<P> {
         &mut self,
         pass: &dyn OperationPass,
         op: &OperationRef,
-        changed: IRAfterPass,
+        changed: PostPassStatus,
     ) {
         (**self).run_after_pass(pass, op, changed);
     }
@@ -115,7 +115,7 @@ impl PassInstrumentor {
         &self,
         pass: &dyn OperationPass,
         op: &OperationRef,
-        changed: IRAfterPass,
+        changed: PostPassStatus,
     ) {
         self.instrument(|pi| pi.run_after_pass(pass, op, changed));
     }

hir/src/pass/manager.rs

@@ -9,7 +9,7 @@ use super::{
     PassInstrumentor, PipelineParentInfo, Statistic,
 };
 use crate::{
-    pass::{pass::PassIdentifier, IRAfterPass, Print},
+    pass::{pass::PassIdentifier, PostPassStatus, Print},
     traits::IsolatedFromAbove,
     Context, EntityMut, OpPrintingFlags, OpRegistration, Operation, OperationName, OperationRef,
     Report,
@@ -987,7 +987,7 @@ impl OpToOpPassAdaptor {
             let in_result = if let Ok(result) = result {
                 result
             } else {
-                IRAfterPass::Unchanged
+                PostPassStatus::IRUnchanged
             };
             if result.is_err() {
                 instrumentor.run_after_pass_failed(pass, &op);
@@ -1014,7 +1014,7 @@ impl OpToOpPassAdaptor {
         op: OperationRef,
         state: &mut PassExecutionState,
         verify: bool,
-    ) -> Result<IRAfterPass, Report> {
+    ) -> Result<PostPassStatus, Report> {
         let analysis_manager = state.analysis_manager();
         let instrumentor = analysis_manager.pass_instrumentor();
         let parent_info = PipelineParentInfo {
@@ -1049,7 +1049,7 @@ impl OpToOpPassAdaptor {
             }
         }
 
-        Ok(IRAfterPass::Unchanged)
+        Ok(PostPassStatus::IRUnchanged)
     }
 }
 
@@ -1090,7 +1090,7 @@ impl Pass for OpToOpPassAdaptor {
         &mut self,
         _op: EntityMut<'_, Operation>,
         _state: &mut PassExecutionState,
-    ) -> Result<IRAfterPass, Report> {
+    ) -> Result<PostPassStatus, Report> {
         unreachable!("unexpected call to `Pass::run_on_operation` for OpToOpPassAdaptor")
     }
 }

hir/src/pass/pass.rs

@@ -47,7 +47,7 @@ pub trait OperationPass {
         &mut self,
         op: OperationRef,
         state: &mut PassExecutionState,
-    ) -> Result<IRAfterPass, Report>;
+    ) -> Result<PostPassStatus, Report>;
     fn run_pipeline(
         &mut self,
         pipeline: &mut OpPassManager,
@@ -128,7 +128,7 @@ where
         &mut self,
         mut op: OperationRef,
         state: &mut PassExecutionState,
-    ) -> Result<IRAfterPass, Report> {
+    ) -> Result<PostPassStatus, Report> {
         let op = <<P as Pass>::Target as PassTarget>::into_target_mut(&mut op);
         <P as Pass>::run_on_operation(self, op, state)
     }
@@ -171,17 +171,17 @@ impl From<&String> for PassIdentifier {
 }
 
 #[derive(Debug, PartialEq, Clone, Copy)]
-pub enum IRAfterPass {
-    Unchanged,
-    Changed,
+pub enum PostPassStatus {
+    IRUnchanged,
+    IRChanged,
 }
 
 // NOTE: I am not sure if using a From impl
-impl From<bool> for IRAfterPass {
+impl From<bool> for PostPassStatus {
     fn from(ir_was_changed: bool) -> Self {
         match ir_was_changed {
-            true => IRAfterPass::Changed,
-            false => IRAfterPass::Unchanged,
+            true => PostPassStatus::IRChanged,
+            false => PostPassStatus::IRUnchanged,
         }
     }
 }
@@ -281,7 +281,7 @@ pub trait Pass: Sized + Any {
         &mut self,
         op: EntityMut<'_, Self::Target>,
         state: &mut PassExecutionState,
-    ) -> Result<IRAfterPass, Report>;
+    ) -> Result<PostPassStatus, Report>;
     /// Schedule an arbitrary pass pipeline on the provided operation.
     ///
     /// This can be invoke any time in a pass to dynamic schedule more passes. The provided
@@ -386,7 +386,7 @@ where
         &mut self,
         op: EntityMut<'_, Self::Target>,
         state: &mut PassExecutionState,
-    ) -> Result<IRAfterPass, Report> {
+    ) -> Result<PostPassStatus, Report> {
         (**self).run_on_operation(op, state)
     }