[mlir][test] Drop op type from test passes in TestPatterns.cpp

[springerm]

Summary

When possible, use OperationPass<> instead of OperationPass<ModuleOp> or OperationPass<FuncOp>.

mlir/test/lib/Dialect/Test/TestPatterns.cpp

LogicalResult matchAndRewrite(test::OneRegionOp op,
     // Hoisting means removing an op from the enclosing op. I.e., the enclosing
     // op is modified.
     rewriter.updateRootInPlace(op, [&]() { toBeHoisted->moveBefore(op); });
     return success();
   }
 };
 
 struct TestPatternDriver
-    : public PassWrapper<TestPatternDriver, OperationPass<ModuleOp>> {
+    : public PassWrapper<TestPatternDriver, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestPatternDriver)
 
   TestPatternDriver() = default;
   TestPatternDriver(const TestPatternDriver &other) : PassWrapper(other) {}
 
   StringRef getArgument() const final { return "test-patterns"; }
   StringRef getDescription() const final { return "Run test dialect patterns"; }
   void runOnOperation() override {
struct TestTypeConverter : public TypeConverter {
   static std::optional<Value> materializeCast(OpBuilder &builder,
                                               Type resultType,
                                               ValueRange inputs, Location loc) {
     return builder.create<TestCastOp>(loc, resultType, inputs).getResult();
   }
 };
 
 struct TestLegalizePatternDriver
-    : public PassWrapper<TestLegalizePatternDriver, OperationPass<ModuleOp>> {
+    : public PassWrapper<TestLegalizePatternDriver, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLegalizePatternDriver)
 
   StringRef getArgument() const final { return "test-legalize-patterns"; }
   StringRef getDescription() const final {
     return "Run test dialect legalization patterns";
   }
   /// The mode of conversion to use with the driver.
   enum class ConversionMode { Analysis, Full, Partial };
matchAndRewrite(TestRemappedValueRegionOp op, OpAdaptor adaptor,
 
     rewriter.eraseOp(terminator);
     rewriter.replaceOp(op, terminatorOperands);
     return success();
   }
 };
 
 struct TestRemappedValue
-    : public mlir::PassWrapper<TestRemappedValue, OperationPass<func::FuncOp>> {
+    : public mlir::PassWrapper<TestRemappedValue, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestRemappedValue)
 
   StringRef getArgument() const final { return "test-remapped-value"; }
   StringRef getDescription() const final {
     return "Test public remapped value mechanism in ConversionPatternRewriter";
   }
   void runOnOperation() override {
     TestRemapValueTypeConverter typeConverter;
LogicalResult matchAndRewrite(Operation *op,
     if (!isa<TestDialect>(op->getDialect()))
       return failure();
     rewriter.eraseOp(op);
     return success();
   }
 };
 
 struct TestUnknownRootOpDriver
-    : public mlir::PassWrapper<TestUnknownRootOpDriver,
-                               OperationPass<func::FuncOp>> {
+    : public mlir::PassWrapper<TestUnknownRootOpDriver, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestUnknownRootOpDriver)
 
   StringRef getArgument() const final {
     return "test-legalize-unknown-root-patterns";
   }
   StringRef getDescription() const final {
     return "Test public remapped value mechanism in ConversionPatternRewriter";
   }
struct TestTypeConversionAnotherProducer
   LogicalResult matchAndRewrite(TestAnotherTypeProducerOp op,
                                 PatternRewriter &rewriter) const final {
     rewriter.replaceOpWithNewOp<TestTypeProducerOp>(op, op.getType());
     return success();
   }
 };
 
 struct TestTypeConversionDriver
-    : public PassWrapper<TestTypeConversionDriver, OperationPass<ModuleOp>> {
+    : public PassWrapper<TestTypeConversionDriver, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestTypeConversionDriver)
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<TestDialect>();
   }
   StringRef getArgument() const final {
     return "test-legalize-type-conversion";
   }
struct ForwardOperandPattern : public OpConversionPattern<TestTypeChangerOp> {
   matchAndRewrite(TestTypeChangerOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     rewriter.replaceOp(op, adaptor.getOperands());
     return success();
   }
 };
 
 struct TestTargetMaterializationWithNoUses
-    : public PassWrapper<TestTargetMaterializationWithNoUses,
-                         OperationPass<ModuleOp>> {
+    : public PassWrapper<TestTargetMaterializationWithNoUses, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
       TestTargetMaterializationWithNoUses)
 
   StringRef getArgument() const final {
     return "test-target-materialization-with-no-uses";
   }
   StringRef getDescription() const final {
     return "Test a special case of target materialization in DialectConversion";
matchAndRewrite(SingleBlockImplicitTerminatorOp op, OpAdaptor adaptor,
     rewriter.eraseOp(innerTerminator);
     rewriter.eraseOp(op);
     rewriter.updateRootInPlace(op, [] {});
     return success();
   }
 };
 
 struct TestMergeBlocksPatternDriver
-    : public PassWrapper<TestMergeBlocksPatternDriver,
-                         OperationPass<ModuleOp>> {
+    : public PassWrapper<TestMergeBlocksPatternDriver, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestMergeBlocksPatternDriver)
 
   StringRef getArgument() const final { return "test-merge-blocks"; }
   StringRef getDescription() const final {
     return "Test Merging operation in ConversionPatternRewriter";
   }
   void runOnOperation() override {
     MLIRContext *context = &getContext();