Rename: PassType -> PassIdentifier; pass_type() -> pass_id()

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::PassType, IRAfterPass, Pass, PassExecutionState},
+    pass::{pass::PassIdentifier, IRAfterPass, Pass, PassExecutionState},
     BlockRef, BuilderExt, EntityMut, Op, OpBuilder, OperationName, OperationRef, Report, Rewriter,
     SourceSpan, Spanned, Symbol, ValueRef,
 };
@@ -19,8 +19,8 @@ impl Pass for TransformSpills {
         "transform-spills"
     }
 
-    fn pass_type(&self) -> Option<PassType> {
-        Some(PassType::TransformSpills)
+    fn pass_id(&self) -> Option<PassIdentifier> {
+        Some(PassIdentifier::TransformSpills)
     }
 
     fn argument(&self) -> &'static str {

dialects/scf/src/transforms/cfg_to_scf.rs

@@ -7,7 +7,7 @@ use midenc_hir::{
     diagnostics::Severity,
     dialects::builtin,
     dominance::DominanceInfo,
-    pass::{pass::PassType, IRAfterPass, Pass, PassExecutionState},
+    pass::{pass::PassIdentifier, IRAfterPass, Pass, PassExecutionState},
     Builder, EntityMut, Forward, Op, Operation, OperationName, OperationRef, RawWalk, Report,
     SmallVec, Spanned, Type, ValueRange, ValueRef, WalkResult,
 };
@@ -35,8 +35,8 @@ impl Pass for LiftControlFlowToSCF {
         "lift-control-flow"
     }
 
-    fn pass_type(&self) -> Option<PassType> {
-        Some(PassType::LiftControlFlowToSCF)
+    fn pass_id(&self) -> Option<PassIdentifier> {
+        Some(PassIdentifier::LiftControlFlowToSCF)
     }
 
     fn argument(&self) -> &'static str {

hir-transform/src/canonicalization.rs

@@ -1,7 +1,7 @@
 use alloc::{boxed::Box, format, rc::Rc};
 
 use midenc_hir::{
-    pass::{pass::PassType, IRAfterPass, OperationPass, Pass, PassExecutionState},
+    pass::{pass::PassIdentifier, IRAfterPass, OperationPass, Pass, PassExecutionState},
     patterns::{self, FrozenRewritePatternSet, GreedyRewriteConfig, RewritePatternSet},
     Context, EntityMut, Operation, OperationName, Report, Spanned,
 };
@@ -62,8 +62,8 @@ impl Pass for Canonicalizer {
         "canonicalizer"
     }
 
-    fn pass_type(&self) -> Option<PassType> {
-        Some(PassType::Canonicalizer)
+    fn pass_id(&self) -> Option<PassIdentifier> {
+        Some(PassIdentifier::Canonicalizer)
     }
 
     fn argument(&self) -> &'static str {

hir-transform/src/sccp.rs

@@ -1,5 +1,5 @@
 use midenc_hir::{
-    pass::{pass::PassType, IRAfterPass, Pass, PassExecutionState},
+    pass::{pass::PassIdentifier, IRAfterPass, Pass, PassExecutionState},
     patterns::NoopRewriterListener,
     BlockRef, Builder, EntityMut, OpBuilder, Operation, OperationFolder, OperationName, RegionList,
     Report, SmallVec, ValueRef,
@@ -26,8 +26,8 @@ impl Pass for SparseConditionalConstantPropagation {
         "sparse-conditional-constant-propagation"
     }
 
-    fn pass_type(&self) -> Option<PassType> {
-        Some(PassType::SparseConditionalConstantPropagation)
+    fn pass_id(&self) -> Option<PassIdentifier> {
+        Some(PassIdentifier::SparseConditionalConstantPropagation)
     }
 
     fn argument(&self) -> &'static str {

hir-transform/src/sink.rs

@@ -4,7 +4,7 @@ use midenc_hir::{
     adt::SmallDenseMap,
     dominance::DominanceInfo,
     matchers::{self, Matcher},
-    pass::{pass::PassType, IRAfterPass, Pass, PassExecutionState},
+    pass::{pass::PassIdentifier, IRAfterPass, Pass, PassExecutionState},
     traits::{ConstantLike, Terminator},
     Backward, Builder, EntityMut, Forward, FxHashSet, OpBuilder, Operation, OperationName,
     OperationRef, ProgramPoint, RawWalk, Region, RegionBranchOpInterface,
@@ -84,8 +84,8 @@ impl Pass for ControlFlowSink {
         "control-flow-sink"
     }
 
-    fn pass_type(&self) -> Option<PassType> {
-        Some(PassType::ControlFlowSink)
+    fn pass_id(&self) -> Option<PassIdentifier> {
+        Some(PassIdentifier::ControlFlowSink)
     }
 
     fn argument(&self) -> &'static str {
@@ -165,8 +165,8 @@ impl Pass for SinkOperandDefs {
         "sink-operand-defs"
     }
 
-    fn pass_type(&self) -> Option<PassType> {
-        Some(PassType::SinkOperandDefs)
+    fn pass_id(&self) -> Option<PassIdentifier> {
+        Some(PassIdentifier::SinkOperandDefs)
     }
 
     fn argument(&self) -> &'static str {

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, PassType},
+    pass::{IRAfterPass, OperationPass, Pass, PassExecutionState, PassIdentifier},
     registry::{PassInfo, PassPipelineInfo},
     specialization::PassTarget,
     statistics::{PassStatistic, Statistic, StatisticValue},
@@ -37,7 +37,7 @@ enum PassFilter {
     /// Print IR regardless of which pass is executed.
     All,
     /// Only print IR if the pass's name is present in the vector.
-    Certain(Vec<PassType>),
+    Certain(Vec<PassIdentifier>),
 }
 
 #[derive(Default, Debug)]
@@ -164,7 +164,7 @@ impl Print {
         match &self.pass_filter {
             Some(PassFilter::All) => true,
             Some(PassFilter::Certain(passes)) => passes.iter().any(|p| {
-                if let Some(p_type) = pass.pass_type() {
+                if let Some(p_type) = pass.pass_id() {
                     *p == p_type
                 } else {
                     false

hir/src/pass/manager.rs

@@ -9,7 +9,7 @@ use super::{
     PassInstrumentor, PipelineParentInfo, Statistic,
 };
 use crate::{
-    pass::{pass::PassType, IRAfterPass, Print},
+    pass::{pass::PassIdentifier, IRAfterPass, Print},
     traits::IsolatedFromAbove,
     Context, EntityMut, OpPrintingFlags, OpRegistration, Operation, OperationName, OperationRef,
     Report,
@@ -37,14 +37,14 @@ pub struct IRPrintingConfig {
     pub print_after_only_on_failure: bool,
     // NOTE: Taken from the Options struct
     pub print_ir_after_all: bool,
-    pub print_ir_after_pass: Vec<PassType>,
+    pub print_ir_after_pass: Vec<PassIdentifier>,
     pub print_ir_after_modified: bool,
     pub flags: OpPrintingFlags,
 }
 
 impl From<&Options> for IRPrintingConfig {
     fn from(options: &Options) -> Self {
-        let pass_filters: Vec<PassType> =
+        let pass_filters: Vec<PassIdentifier> =
             options.print_ir_after_pass.iter().map(|a| a.into()).collect();
         IRPrintingConfig {
             print_ir_after_all: options.print_ir_after_all,
@@ -735,7 +735,7 @@ impl OpToOpPassAdaptor {
     }
 
     #[allow(dead_code)]
-    fn pass_type(&self) -> Option<PassType> {
+    fn pass_id(&self) -> Option<PassIdentifier> {
         None
     }
 
@@ -1060,7 +1060,7 @@ impl Pass for OpToOpPassAdaptor {
         crate::interner::Symbol::intern(self.name()).as_str()
     }
 
-    fn pass_type(&self) -> Option<PassType> {
+    fn pass_id(&self) -> Option<PassIdentifier> {
         None
     }
 

hir/src/pass/pass.rs

@@ -16,7 +16,7 @@ pub trait OperationPass {
     fn into_any(self: Box<Self>) -> Box<dyn Any>;
     fn name(&self) -> &'static str;
 
-    fn pass_type(&self) -> Option<PassType>;
+    fn pass_id(&self) -> Option<PassIdentifier>;
 
     fn argument(&self) -> &'static str {
         // NOTE: Could we compute an argument string from the type name?
@@ -64,8 +64,8 @@ where
         <P as Pass>::as_any(self)
     }
 
-    fn pass_type(&self) -> Option<PassType> {
-        <P as Pass>::pass_type(self)
+    fn pass_id(&self) -> Option<PassIdentifier> {
+        <P as Pass>::pass_id(self)
     }
 
     fn as_any_mut(&mut self) -> &mut dyn Any {
@@ -144,7 +144,7 @@ where
 }
 
 #[derive(Debug, PartialEq, Clone, Copy)]
-pub enum PassType {
+pub enum PassIdentifier {
     Canonicalizer,
     ControlFlowSink,
     LiftControlFlowToSCF,
@@ -154,17 +154,17 @@ pub enum PassType {
     TransformSpills,
 }
 
-impl From<&String> for PassType {
+impl From<&String> for PassIdentifier {
     fn from(pass_name: &String) -> Self {
         match pass_name.as_str() {
-            "canonicalizer" => PassType::Canonicalizer,
-            "control-flow-sink" => PassType::ControlFlowSink,
-            "lift-control-flow" => PassType::LiftControlFlowToSCF,
-            "sink-operand-defs" => PassType::SinkOperandDefs,
+            "canonicalizer" => PassIdentifier::Canonicalizer,
+            "control-flow-sink" => PassIdentifier::ControlFlowSink,
+            "lift-control-flow" => PassIdentifier::LiftControlFlowToSCF,
+            "sink-operand-defs" => PassIdentifier::SinkOperandDefs,
             "sparse-conditional-constant-propagation" => {
-                PassType::SparseConditionalConstantPropagation
+                PassIdentifier::SparseConditionalConstantPropagation
             }
-            "transform-spills" => PassType::TransformSpills,
+            "transform-spills" => PassIdentifier::TransformSpills,
             _ => panic!("ERROR: '{pass_name}' unrecognized pass."),
         }
     }
@@ -295,7 +295,7 @@ pub trait Pass: Sized + Any {
         state.run_pipeline(pipeline, op)
     }
 
-    fn pass_type(&self) -> Option<PassType>;
+    fn pass_id(&self) -> Option<PassIdentifier>;
 }
 
 impl<P> Pass for Box<P>
@@ -322,8 +322,8 @@ where
         (**self).name()
     }
 
-    fn pass_type(&self) -> Option<PassType> {
-        (**self).pass_type()
+    fn pass_id(&self) -> Option<PassIdentifier> {
+        (**self).pass_id()
     }
 
     #[inline]