[NFC] Switch to new pass generation tablegen definitions.

This commit completes the migration from the deprecated GEN_PASS_CLASSES
to the new GEN_PASS_DEF infrastructure across all torch-mlir passes.

Changes include:

1. Remove PassDetail.h files (deprecated pattern)
   - Deleted lib/Conversion/PassDetail.h
   - Deleted lib/RefBackend/PassDetail.h
   - Deleted lib/Dialect/Torch/Transforms/PassDetail.h
   - Deleted lib/Dialect/TorchConversion/Transforms/PassDetail.h
   - Deleted lib/Dialect/TMTensor/Transforms/PassDetail.h

2. Migrate conversion passes to GEN_PASS_DEF
   - Updated all passes in lib/Conversion/ to use #define GEN_PASS_DEF_*
   - Removed GEN_PASS_DECL from .cpp files (move to headers where needed)
   - Fixed includes and namespace declarations

3. Migrate dialect transform passes
   - Updated Torch, TorchConversion, and TMTensor transform passes
   - Properly scoped GEN_PASS_DEF in namespace blocks

4. Handle passes with options (TorchToStablehlo, TorchToTosa)
   - Added GEN_PASS_DECL_* to headers
   - Implemented default and convenience create functions
   - Used generated constructors via `using BaseClass::BaseClass`

5. Handle passes without options (RefBackend)
   - Removed manual create function implementations
   - Let tablegen auto-generate create functions
   - Added using declarations for Base classes in impl namespace

6. Fix backend type conversion passes
   - Added missing create functions in BackendTypeConversionPasses.cpp
   - Fixed namespace scoping issues

7. Fix missing namespace closures
   - Added proper closing namespace comments in Verify*BackendContract.cpp

The migration maintains full backward compatibility while adopting the
recommended LLVM pass infrastructure patterns. All passes now use the
generated base classes and follow consistent patterns based on whether
they have options defined in tablegen.

Signed-off-by: hanhanW <[email protected]>

Author: hanhanW

include/torch-mlir-dialects/Dialect/TMTensor/Transforms/PassDetail.h

@@ -16,10 +16,18 @@
 
 namespace mlir {
 namespace torch {
+
+#define GEN_PASS_DECL_CONVERTTORCHTOSTABLEHLO
+#include "torch-mlir/Conversion/Passes.h.inc"
+
 std::unique_ptr<OperationPass<func::FuncOp>>
 createConvertTorchToStablehloPass();
+
+// Convenience wrapper for users who want to pass options as individual
+// parameters
 std::unique_ptr<OperationPass<func::FuncOp>>
 createConvertTorchToStablehloPass(bool enableStaticShape, bool enableI32Index);
+
 } // namespace torch
 } // namespace mlir
 

include/torch-mlir/Conversion/TorchToStablehlo/TorchToStablehlo.h

@@ -19,6 +19,9 @@
 namespace mlir {
 namespace torch {
 
+#define GEN_PASS_DECL_CONVERTTORCHTOTOSA
+#include "torch-mlir/Conversion/Passes.h.inc"
+
 /// Collect a set of legal/illegal ops for converting Torch operations to Tosa
 /// dialect.
 void populateTorchToTosaConversionLegalOps(ConversionTarget &target);
@@ -30,8 +33,12 @@ populateTorchToTosaConversionPatternsAndIllegalOps(TypeConverter &typeConverter,
                                                    RewritePatternSet &patterns);
 
 std::unique_ptr<OperationPass<func::FuncOp>> createConvertTorchToTosaPass();
+
+// Convenience wrapper for users who want to pass options as individual
+// parameters
 std::unique_ptr<OperationPass<func::FuncOp>>
 createConvertTorchToTosaPass(bool requireFullTosaConversion);
+
 } // namespace torch
 } // namespace mlir
 

include/torch-mlir/Conversion/TorchToTosa/TorchToTosa.h

@@ -15,25 +15,12 @@
 #include "mlir/Pass/PassManager.h"
 
 namespace mlir {
-class ModuleOp;
-
 namespace torch {
 namespace RefBackend {
 
 /// Registers all RefBackend passes.
 void registerRefBackendPasses();
 
-std::unique_ptr<OperationPass<ModuleOp>> createMungeCallingConventionsPass();
-
-std::unique_ptr<OperationPass<func::FuncOp>> createExpandOpsForLLVMPass();
-
-std::unique_ptr<OperationPass<ModuleOp>> createMLProgramBufferizePass();
-
-std::unique_ptr<OperationPass<func::FuncOp>> createMungeMemrefCopyPass();
-
-std::unique_ptr<OperationPass<func::FuncOp>> createGeneralizeTensorConcatPass();
-
-std::unique_ptr<OperationPass<func::FuncOp>> createGeneralizeTensorPadPass();
 } // namespace RefBackend
 } // namespace torch
 } // namespace mlir

include/torch-mlir/RefBackend/Passes.h

@@ -14,35 +14,29 @@ include "mlir/Pass/PassBase.td"
 
 def MungeCallingConventions : Pass<"refback-munge-calling-conventions", "ModuleOp"> {
   let summary = "Munge calling conventions for calling via ExecutionEngine";
-  let constructor = "mlir::torch::RefBackend::createMungeCallingConventionsPass();";
   let dependentDialects = ["memref::MemRefDialect"];
 }
 
 def MLProgramBufferize: Pass<"refback-mlprogram-bufferize", "ModuleOp"> {
   let summary = "Bufferize the MLProgram dialect ops";
-  let constructor = "mlir::torch::RefBackend::createMLProgramBufferizePass();";
   let dependentDialects = ["memref::MemRefDialect"];
 }
 
 def ExpandOpsForLLVM : Pass<"refback-expand-ops-for-llvm", "func::FuncOp"> {
   let summary = "Expand ops into more primitive ops before LLVM lowering.";
-  let constructor = "mlir::torch::RefBackend::createExpandOpsForLLVMPass();";
 }
 
 def MungeMemrefCopy : Pass<"refback-munge-memref-copy", "func::FuncOp"> {
   let summary = "Munge memref.copy to linalg.copy";
-  let constructor = "mlir::torch::RefBackend::createMungeMemrefCopyPass();";
   let dependentDialects = ["memref::MemRefDialect"];
 }
 
 def GeneralizeTensorConcat : Pass<"refback-generalize-tensor-concat", "func::FuncOp"> {
   let summary = "Convert tensor.concat to other tensor ops";
-  let constructor = "mlir::torch::RefBackend::createGeneralizeTensorConcatPass()";
 }
 
 def GeneralizeTensorPad : Pass<"refback-generalize-tensor-pad", "func::FuncOp"> {
   let summary = "Convert tensor.pad to linalg ops";
-  let constructor = "mlir::torch::RefBackend::createGeneralizeTensorPadPass()";
 }
 
 #endif // TORCHMLIR_REFBACKEND_PASSES

include/torch-mlir/RefBackend/Passes.td

@@ -8,8 +8,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "torch-mlir/Conversion/TorchConversionToMLProgram/TorchConversionToMLProgram.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Pass/Pass.h"
+#include "torch-mlir/Conversion/Passes.h"
 
-#include "../PassDetail.h"
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/MLProgram/IR/MLProgram.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
@@ -20,6 +22,10 @@ using namespace mlir;
 using namespace mlir::torch;
 using namespace mlir::torch::Torch;
 using namespace mlir::torch::TorchConversion;
+namespace mlir::torch {
+
+#define GEN_PASS_DEF_CONVERTTORCHCONVERSIONTOMLPROGRAM
+#include "torch-mlir/Conversion/Passes.h.inc"
 
 static constexpr StringRef getSeedGobalVarName() { return "global_seed"; }
 
@@ -102,7 +108,7 @@ class ConvertGetNextSeedOp : public OpConversionPattern<GetNextSeedOp> {
 
 namespace {
 class ConvertTorchConversionToMLProgram
-    : public ConvertTorchConversionToMLProgramBase<
+    : public impl::ConvertTorchConversionToMLProgramBase<
           ConvertTorchConversionToMLProgram> {
 public:
   void getDependentDialects(DialectRegistry &registry) const override {
@@ -138,6 +144,8 @@ class ConvertTorchConversionToMLProgram
 } // namespace
 
 std::unique_ptr<OperationPass<ModuleOp>>
-mlir::torch::createConvertTorchConversionToMLProgramPass() {
+createConvertTorchConversionToMLProgramPass() {
   return std::make_unique<ConvertTorchConversionToMLProgram>();
 }
+
+} // namespace mlir::torch

lib/Conversion/PassDetail.h

@@ -7,7 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "./PassDetail.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Support/LLVM.h"
 #include "torch-mlir/Conversion/TorchOnnxToTorch/Passes.h"
 #include "torch-mlir/Conversion/TorchOnnxToTorch/Patterns.h"
@@ -19,6 +20,10 @@ using llvm::dbgs;
 using namespace mlir;
 using namespace mlir::torch;
 using namespace mlir::torch::onnx_c;
+namespace mlir::torch::onnx_c {
+
+#define GEN_PASS_DEF_CONVERTTORCHONNXTOTORCH
+#include "torch-mlir/Conversion/TorchOnnxToTorch/Passes.h.inc"
 
 #define DEBUG_TYPE "torch-onnx"
 
@@ -37,7 +42,7 @@ int64_t getDefaultOpsetVersion(Operation *containerOp) {
 }
 
 class ConvertTorchOnnxToTorch
-    : public ConvertTorchOnnxToTorchBase<ConvertTorchOnnxToTorch> {
+    : public impl::ConvertTorchOnnxToTorchBase<ConvertTorchOnnxToTorch> {
 public:
   ConvertTorchOnnxToTorch() = default;
   void runOnOperation() override {
@@ -82,7 +87,8 @@ class ConvertTorchOnnxToTorch
 
 } // namespace
 
-std::unique_ptr<OperationPass<func::FuncOp>>
-mlir::torch::onnx_c::createTorchOnnxToTorchPass() {
+std::unique_ptr<OperationPass<func::FuncOp>> createTorchOnnxToTorchPass() {
   return std::make_unique<ConvertTorchOnnxToTorch>();
 }
+
+} // namespace mlir::torch::onnx_c

lib/Conversion/TorchConversionToMLProgram/TorchConversionToMLProgram.cpp

@@ -8,8 +8,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "torch-mlir/Conversion/TorchToArith/TorchToArith.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Pass/Pass.h"
+#include "torch-mlir/Conversion/Passes.h"
 
-#include "../PassDetail.h"
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/Math/IR/Math.h"
@@ -25,6 +27,10 @@
 using namespace mlir;
 using namespace mlir::torch;
 using namespace mlir::torch::Torch;
+namespace mlir::torch {
+
+#define GEN_PASS_DEF_CONVERTTORCHTOARITH
+#include "torch-mlir/Conversion/Passes.h.inc"
 
 // -----------------------------------------------------------------------------
 // Patterns (as this grows, it should be organized into multiple files)
@@ -407,7 +413,7 @@ class ConvertAtenBoolLikeOp : public OpConversionPattern<OpTy> {
 
 namespace {
 class ConvertTorchToArith
-    : public ConvertTorchToArithBase<ConvertTorchToArith> {
+    : public impl::ConvertTorchToArithBase<ConvertTorchToArith> {
 public:
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<func::FuncDialect>();
@@ -565,7 +571,8 @@ class ConvertTorchToArith
 };
 } // namespace
 
-std::unique_ptr<OperationPass<func::FuncOp>>
-mlir::torch::createConvertTorchToArithPass() {
+std::unique_ptr<OperationPass<func::FuncOp>> createConvertTorchToArithPass() {
   return std::make_unique<ConvertTorchToArith>();
 }
+
+} // namespace mlir::torch