Introduce th IRAfterPass enum. Replace the usage of bool to indicate IR modification with this enum.

This is done in order to make IR modification more explicit and introduce it in
the type system.

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, PassExecutionState},
+    pass::{IRAfterPass, Pass, PassExecutionState},
     BlockRef, BuilderExt, EntityMut, Op, OpBuilder, OperationName, OperationRef, Report, Rewriter,
     SourceSpan, Spanned, Symbol, ValueRef,
 };
@@ -31,22 +31,22 @@ impl Pass for TransformSpills {
         &mut self,
         op: EntityMut<'_, Self::Target>,
         state: &mut PassExecutionState,
-    ) -> Result<bool, Report> {
+    ) -> Result<IRAfterPass, 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(false);
+            return Ok(IRAfterPass::Unchanged);
         }
         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(false);
+            return Ok(IRAfterPass::Unchanged);
         }
 
         // 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, PassExecutionState},
+    pass::{IRAfterPass, Pass, PassExecutionState},
     Builder, EntityMut, Forward, Op, Operation, OperationName, OperationRef, RawWalk, Report,
     SmallVec, Spanned, Type, ValueRange, ValueRef, WalkResult,
 };
@@ -51,7 +51,7 @@ impl Pass for LiftControlFlowToSCF {
         &mut self,
         op: EntityMut<'_, Self::Target>,
         state: &mut PassExecutionState,
-    ) -> Result<bool, Report> {
+    ) -> Result<IRAfterPass, Report> {
         let mut transformation = ControlFlowToSCFTransformation;
         let mut changed = false;
 
@@ -131,7 +131,7 @@ impl Pass for LiftControlFlowToSCF {
 
         if result.was_interrupted() {
             // TODO: Maybe Change into_result implementation
-            return result.into_result().map(|_| false);
+            return result.into_result().map(|_| IRAfterPass::Unchanged);
         }
 
         log::debug!(
@@ -142,7 +142,7 @@ impl Pass for LiftControlFlowToSCF {
             state.preserved_analyses_mut().preserve_all();
         }
 
-        Ok(changed)
+        Ok(changed.into())
     }
 }
 

hir-transform/src/canonicalization.rs

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

hir-transform/src/sccp.rs

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

hir-transform/src/sink.rs

@@ -4,7 +4,7 @@ use midenc_hir::{
     adt::SmallDenseMap,
     dominance::DominanceInfo,
     matchers::{self, Matcher},
-    pass::{Pass, PassExecutionState},
+    pass::{IRAfterPass, Pass, PassExecutionState},
     traits::{ConstantLike, Terminator},
     Backward, Builder, EntityMut, Forward, FxHashSet, OpBuilder, Operation, OperationName,
     OperationRef, ProgramPoint, RawWalk, Region, RegionBranchOpInterface,
@@ -96,7 +96,7 @@ impl Pass for ControlFlowSink {
         &mut self,
         op: EntityMut<'_, Self::Target>,
         state: &mut PassExecutionState,
-    ) -> Result<bool, Report> {
+    ) -> Result<IRAfterPass, Report> {
         let op = op.into_entity_ref();
         log::debug!(target: "control-flow-sink", "sinking operations in {op}");
 
@@ -105,7 +105,7 @@ impl Pass for ControlFlowSink {
 
         let dominfo = state.analysis_manager().get_analysis::<DominanceInfo>()?;
 
-        let mut sunk = false;
+        let mut sunk = IRAfterPass::Unchanged;
         operation.raw_prewalk_all::<Forward, _>(|op: OperationRef| {
             let regions_to_sink = {
                 let op = op.borrow();
@@ -173,7 +173,7 @@ impl Pass for SinkOperandDefs {
         &mut self,
         op: EntityMut<'_, Self::Target>,
         _state: &mut PassExecutionState,
-    ) -> Result<bool, Report> {
+    ) -> Result<IRAfterPass, Report> {
         let operation = op.as_operation_ref();
         drop(op);
 
@@ -185,7 +185,7 @@ impl Pass for SinkOperandDefs {
         // then process the worklist, moving everything into position.
         let mut worklist = alloc::collections::VecDeque::default();
 
-        let mut changed = false;
+        let mut changed = IRAfterPass::Unchanged;
         // 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:
@@ -310,7 +310,7 @@ impl Pass for SinkOperandDefs {
                         log::trace!(target: "sink-operand-defs", "    rewriting operand {operand_value} as {replacement}");
                         operand.borrow_mut().set(replacement);
 
-                        changed = true;
+                        changed = IRAfterPass::Changed;
                         // If no other uses of this value remain, then remove the original
                         // operation, as it is now dead.
                         if !operand_value.borrow().is_used() {
@@ -357,7 +357,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 = true;
+                        changed = IRAfterPass::Changed;
                     } 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
@@ -552,14 +552,14 @@ pub fn control_flow_sink<P, F>(
     dominfo: &DominanceInfo,
     should_move_into_region: P,
     move_into_region: F,
-) -> bool
+) -> IRAfterPass
 where
     P: Fn(&Operation, &Region) -> bool,
     F: Fn(OperationRef, RegionRef),
 {
     let sinker = Sinker::new(dominfo, should_move_into_region, move_into_region);
     let sunk_regions = sinker.sink_regions(regions);
-    sunk_regions > 0
+    (sunk_regions > 0).into()
 }
 
 /// Populates `regions` with regions of the provided region branch op that are executed at most once

hir-transform/src/spill.rs

@@ -4,7 +4,7 @@ use midenc_hir::{
     adt::{SmallDenseMap, SmallSet},
     cfg::Graph,
     dominance::{DomTreeNode, DominanceFrontier, DominanceInfo},
-    pass::AnalysisManager,
+    pass::{AnalysisManager, IRAfterPass},
     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<bool, Report> {
+) -> Result<IRAfterPass, Report> {
     assert!(
         op.borrow().implements::<dyn SingleRegion>(),
         "the spills transformation is not supported when the root op is multi-region"
@@ -253,7 +253,7 @@ pub fn transform_spills(
     }
 
     // QUESTION: If the code has reached this point, then, in theory, it must've gotten changed. Right? Requires double check.
-    Ok(true)
+    Ok(IRAfterPass::Changed)
 }
 
 fn rewrite_single_block_spills(

hir/src/pass.rs

@@ -11,7 +11,7 @@ pub use self::{
     analysis::{Analysis, AnalysisManager, OperationAnalysis, PreservedAnalyses},
     instrumentation::{PassInstrumentation, PassInstrumentor, PipelineParentInfo},
     manager::{IRPrintingConfig, Nesting, OpPassManager, PassDisplayMode, PassManager},
-    pass::{OperationPass, Pass, PassExecutionState},
+    pass::{IRAfterPass, OperationPass, Pass, PassExecutionState},
     registry::{PassInfo, PassPipelineInfo},
     specialization::PassTarget,
     statistics::{PassStatistic, Statistic, StatisticValue},
@@ -168,26 +168,31 @@ impl Pass for Print {
         &mut self,
         op: crate::EntityMut<'_, Self::Target>,
         _state: &mut PassExecutionState,
-    ) -> Result<bool, crate::Report> {
+    ) -> Result<IRAfterPass, crate::Report> {
         let op = op.into_entity_ref();
         self.print_ir(op);
-        Ok(false)
+        Ok(IRAfterPass::Unchanged)
     }
 }
 
 impl PassInstrumentation for Print {
-    fn run_after_pass(&mut self, pass: &dyn OperationPass, op: &OperationRef, changed: bool) {
+    fn run_after_pass(
+        &mut self,
+        pass: &dyn OperationPass,
+        op: &OperationRef,
+        changed: IRAfterPass,
+    ) {
         std::println!(
             "
 ------------------------------------DESPUES:\
              {}-------------------------------------------------------
 ",
             pass.name()
         );
-        std::println!("RESULTADO DE CHANGED: {}", changed);
+        // std::println!("RESULTADO DE CHANGED: {}", changed);
         #[allow(clippy::needless_bool)]
         // Always print, unless "only_when_modified" has been set and there have not been changes.
-        let print_when_changed = if self.only_when_modified && !changed {
+        let print_when_changed = if self.only_when_modified && changed == IRAfterPass::Unchanged {
             false
         } else {
             true

hir/src/pass/instrumentation.rs

@@ -5,7 +5,7 @@ use compact_str::CompactString;
 use smallvec::SmallVec;
 
 use super::OperationPass;
-use crate::{OperationName, OperationRef};
+use crate::{pass::IRAfterPass, OperationName, OperationRef};
 
 #[allow(unused_variables)]
 pub trait PassInstrumentation {
@@ -22,7 +22,13 @@ pub trait PassInstrumentation {
     ) {
     }
     fn run_before_pass(&mut self, pass: &dyn OperationPass, op: &OperationRef) {}
-    fn run_after_pass(&mut self, pass: &dyn OperationPass, op: &OperationRef, changed: bool) {}
+    fn run_after_pass(
+        &mut self,
+        pass: &dyn OperationPass,
+        op: &OperationRef,
+        changed: IRAfterPass,
+    ) {
+    }
     fn run_after_pass_failed(&mut self, pass: &dyn OperationPass, op: &OperationRef) {}
     fn run_before_analysis(&mut self, name: &str, id: &TypeId, op: &OperationRef) {}
     fn run_after_analysis(&mut self, name: &str, id: &TypeId, op: &OperationRef) {}
@@ -54,7 +60,12 @@ impl<P: ?Sized + PassInstrumentation> PassInstrumentation for Box<P> {
         (**self).run_before_pass(pass, op);
     }
 
-    fn run_after_pass(&mut self, pass: &dyn OperationPass, op: &OperationRef, changed: bool) {
+    fn run_after_pass(
+        &mut self,
+        pass: &dyn OperationPass,
+        op: &OperationRef,
+        changed: IRAfterPass,
+    ) {
         (**self).run_after_pass(pass, op, changed);
     }
 
@@ -97,7 +108,12 @@ impl PassInstrumentor {
         self.instrument(|pi| pi.run_before_pass(pass, op));
     }
 
-    pub fn run_after_pass(&self, pass: &dyn OperationPass, op: &OperationRef, changed: bool) {
+    pub fn run_after_pass(
+        &self,
+        pass: &dyn OperationPass,
+        op: &OperationRef,
+        changed: IRAfterPass,
+    ) {
         self.instrument(|pi| pi.run_after_pass(pass, op, changed));
     }