[mlir] Finish replacing OwningRewritePatternList with RewritePatternSet

[rriddle]

Summary

OwningRewritePatternList has been deprecated for ~10 months now, we can remove
the leftover using directives at this point.

Depends on D118285

flang/lib/Optimizer/CodeGen/CodeGen.cpp

public:
   void runOnOperation() override final {
     auto mod = getModule();
     if (!forcedTargetTriple.empty()) {
       fir::setTargetTriple(mod, forcedTargetTriple);
     }
 
     auto *context = getModule().getContext();
     fir::LLVMTypeConverter typeConverter{getModule()};
-    mlir::OwningRewritePatternList pattern(context);
+    mlir::RewritePatternSet pattern(context);
     pattern.insert<
         AbsentOpConversion, AddcOpConversion, AddrOfOpConversion,
         AllocaOpConversion, AllocMemOpConversion, BoxAddrOpConversion,
         BoxCharLenOpConversion, BoxDimsOpConversion, BoxEleSizeOpConversion,
         BoxIsAllocOpConversion, BoxIsArrayOpConversion, BoxIsPtrOpConversion,
         BoxProcHostOpConversion, BoxRankOpConversion, BoxTypeDescOpConversion,
         CallOpConversion, CmpcOpConversion, ConstcOpConversion,
         ConvertOpConversion, CoordinateOpConversion, DispatchOpConversion,

flang/lib/Optimizer/CodeGen/PreCGRewrite.cpp

void runOnOperation() override final {
     target.addLegalDialect<mlir::arith::ArithmeticDialect, FIROpsDialect,
                            FIRCodeGenDialect, mlir::StandardOpsDialect>();
     target.addIllegalOp<ArrayCoorOp>();
     target.addIllegalOp<ReboxOp>();
     target.addDynamicallyLegalOp<EmboxOp>([](EmboxOp embox) {
       return !(embox.getShape() ||
                embox.getType().cast<BoxType>().getEleTy().isa<SequenceType>());
     });
-    mlir::OwningRewritePatternList patterns(&context);
+    mlir::RewritePatternSet patterns(&context);
     patterns.insert<EmboxConversion, ArrayCoorConversion, ReboxConversion>(
         &context);
     if (mlir::failed(
             mlir::applyPartialConversion(op, target, std::move(patterns)))) {
       mlir::emitError(mlir::UnknownLoc::get(&context),
                       "error in running the pre-codegen conversions");
       signalPassFailure();
     }
   }
 };
 
 } // namespace
 
 std::unique_ptr<mlir::Pass> fir::createFirCodeGenRewritePass() {
   return std::make_unique<CodeGenRewrite>();
 }

flang/lib/Optimizer/Dialect/FIROps.cpp

if (!op.getType().isa<fir::ComplexType>())
     return op.emitOpError("must be a !fir.complex type");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ConvertOp
 //===----------------------------------------------------------------------===//
 
-void fir::ConvertOp::getCanonicalizationPatterns(
-    OwningRewritePatternList &results, MLIRContext *context) {
+void fir::ConvertOp::getCanonicalizationPatterns(RewritePatternSet &results,
+                                                 MLIRContext *context) {
   results.insert<ConvertConvertOptPattern, RedundantConvertOptPattern,
                  CombineConvertOptPattern, ForwardConstantConvertPattern>(
       context);
 }
 
 mlir::OpFoldResult fir::ConvertOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
   if (value().getType() == getType())
     return value();
if (!eai || !ebi || !ear || !ebr || ear.adt() != eai.adt() ||
         !isZero(ebr.coor()[0]))
       return mlir::failure();
     rewriter.replaceOpWithNewOp<CpxOp>(op, ear.adt(), ebr.adt());
     return mlir::success();
   }
 };
 
 void fir::InsertValueOp::getCanonicalizationPatterns(
-    mlir::OwningRewritePatternList &results, mlir::MLIRContext *context) {
+    mlir::RewritePatternSet &results, mlir::MLIRContext *context) {
   results.insert<UndoComplexPattern<mlir::arith::AddFOp, fir::AddcOp>,
                  UndoComplexPattern<mlir::arith::SubFOp, fir::SubcOp>>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // IterWhileOp
 //===----------------------------------------------------------------------===//
 

flang/lib/Optimizer/Transforms/AbstractResult.cpp

 };
 
 class AbstractResultOpt : public fir::AbstractResultOptBase<AbstractResultOpt> {
 public:
   void runOnOperation() override {
     auto *context = &getContext();
     auto func = getOperation();
     auto loc = func.getLoc();
-    mlir::OwningRewritePatternList patterns(context);
+    mlir::RewritePatternSet patterns(context);
     mlir::ConversionTarget target = *context;
     AbstractResultOptions options{passResultAsBox.getValue(),
                                   /*newArg=*/{}};
 
     // Convert function type itself if it has an abstract result
     auto funcTy = func.getType().cast<mlir::FunctionType>();
     if (mustConvertCallOrFunc(funcTy)) {
       func.setType(getNewFunctionType(funcTy, options));

flang/lib/Optimizer/Transforms/AffineDemotion.cpp

class AffineDialectDemotion
     : public AffineDialectDemotionBase<AffineDialectDemotion> {
 public:
   void runOnOperation() override {
     auto *context = &getContext();
     auto function = getOperation();
     LLVM_DEBUG(llvm::dbgs() << "AffineDemotion: running on function:\n";
                function.print(llvm::dbgs()););
 
-    mlir::OwningRewritePatternList patterns(context);
+    mlir::RewritePatternSet patterns(context);
     patterns.insert<ConvertConversion>(context);
     patterns.insert<AffineLoadConversion>(context);
     patterns.insert<AffineStoreConversion>(context);
     patterns.insert<StdAllocConversion>(context);
     mlir::ConversionTarget target(*context);
     target.addIllegalOp<memref::AllocOp>();
     target.addDynamicallyLegalOp<fir::ConvertOp>([](fir::ConvertOp op) {
       if (op.res().getType().isa<mlir::MemRefType>())

flang/lib/Optimizer/Transforms/AffinePromotion.cpp

class AffineDialectPromotion
     : public AffineDialectPromotionBase<AffineDialectPromotion> {
 public:
   void runOnOperation() override {
 
     auto *context = &getContext();
     auto function = getOperation();
     markAllAnalysesPreserved();
     auto functionAnalysis = AffineFunctionAnalysis(function);
-    mlir::OwningRewritePatternList patterns(context);
+    mlir::RewritePatternSet patterns(context);
     patterns.insert<AffineIfConversion>(context, functionAnalysis);
     patterns.insert<AffineLoopConversion>(context, functionAnalysis);
     mlir::ConversionTarget target = *context;
     target.addLegalDialect<
         mlir::AffineDialect, FIROpsDialect, mlir::scf::SCFDialect,
         mlir::arith::ArithmeticDialect, mlir::StandardOpsDialect>();
     target.addDynamicallyLegalOp<IfOp>([&functionAnalysis](fir::IfOp op) {
       return !(functionAnalysis.getChildIfAnalysis(op).canPromoteToAffine());

flang/lib/Optimizer/Transforms/ArrayValueCopy.cpp

void runOnOperation() override {
     // Perform the conflict analysis.
     auto &analysis = getAnalysis<ArrayCopyAnalysis>();
     const auto &useMap = analysis.getUseMap();
 
     // Phase 1 is performing a rewrite on the array accesses. Once all the
     // array accesses are rewritten we can go on phase 2.
     // Phase 2 gets rid of the useless copy-in/copyout operations. The copy-in
     // /copy-out refers the Fortran copy-in/copy-out semantics on statements.
-    mlir::OwningRewritePatternList patterns1(context);
+    mlir::RewritePatternSet patterns1(context);
     patterns1.insert<ArrayFetchConversion>(context, useMap);
     patterns1.insert<ArrayUpdateConversion>(context, analysis, useMap);
     patterns1.insert<ArrayModifyConversion>(context, analysis, useMap);
     mlir::ConversionTarget target(*context);
     target.addLegalDialect<FIROpsDialect, mlir::scf::SCFDialect,
                            mlir::arith::ArithmeticDialect,
                            mlir::StandardOpsDialect>();
     target.addIllegalOp<ArrayFetchOp, ArrayUpdateOp, ArrayModifyOp>();
     // Rewrite the array fetch and array update ops.
     if (mlir::failed(
             mlir::applyPartialConversion(func, target, std::move(patterns1)))) {
       mlir::emitError(mlir::UnknownLoc::get(context),
                       "failure in array-value-copy pass, phase 1");
       signalPassFailure();
     }
 
-    mlir::OwningRewritePatternList patterns2(context);
+    mlir::RewritePatternSet patterns2(context);
     patterns2.insert<ArrayLoadConversion>(context);
     patterns2.insert<ArrayMergeStoreConversion>(context);
     target.addIllegalOp<ArrayLoadOp, ArrayMergeStoreOp>();
     if (mlir::failed(
             mlir::applyPartialConversion(func, target, std::move(patterns2)))) {
       mlir::emitError(mlir::UnknownLoc::get(context),
                       "failure in array-value-copy pass, phase 2");
       signalPassFailure();
     }
   }
 };
 } // namespace
 
 std::unique_ptr<mlir::Pass> fir::createArrayValueCopyPass() {
   return std::make_unique<ArrayValueCopyConverter>();
 }

flang/lib/Optimizer/Transforms/CharacterConversion.cpp

 class CharacterConversion
     : public fir::CharacterConversionBase<CharacterConversion> {
 public:
   void runOnOperation() override {
     CharacterConversionOptions clOpts{useRuntimeCalls.getValue()};
     if (clOpts.runtimeName.empty()) {
       auto *context = &getContext();
       auto *func = getOperation();
-      mlir::OwningRewritePatternList patterns(context);
+      mlir::RewritePatternSet patterns(context);
       patterns.insert<CharacterConvertConversion>(context);
       mlir::ConversionTarget target(*context);
       target.addLegalDialect<mlir::AffineDialect, fir::FIROpsDialect,
                              mlir::arith::ArithmeticDialect,
                              mlir::StandardOpsDialect>();
 
       // apply the patterns
       target.addIllegalOp<fir::CharConvertOp>();

flang/lib/Optimizer/Transforms/ExternalNameConversion.cpp

public:
   void runOnOperation() override;
 };
 } // namespace
 
 void ExternalNameConversionPass::runOnOperation() {
   auto op = getOperation();
   auto *context = &getContext();
 
-  mlir::OwningRewritePatternList patterns(context);
+  mlir::RewritePatternSet patterns(context);
   patterns.insert<MangleNameOnCallOp, MangleNameOnCallOp, MangleNameOnFuncOp,
                   MangleNameForCommonBlock, MangleNameOnAddrOfOp,
                   MangleNameOnEmboxProcOp>(context);
 
   ConversionTarget target(*context);
   target.addLegalDialect<fir::FIROpsDialect, LLVM::LLVMDialect,
                          acc::OpenACCDialect, omp::OpenMPDialect>();
 

flang/lib/Optimizer/Transforms/MemoryAllocation.cpp

if (dynamicArrayOnHeap)
       options.dynamicArrayOnHeap = dynamicArrayOnHeap;
     if (maxStackArraySize != unlimitedArraySize)
       options.maxStackArraySize = maxStackArraySize;
   }
 
   void runOnOperation() override {
     auto *context = &getContext();
     auto func = getOperation();
-    mlir::OwningRewritePatternList patterns(context);
+    mlir::RewritePatternSet patterns(context);
     mlir::ConversionTarget target(*context);
 
     useCommandLineOptions();
     LLVM_DEBUG(llvm::dbgs()
                << "dynamic arrays on heap: " << options.dynamicArrayOnHeap
                << "\nmaximum number of elements of array on stack: "
                << options.maxStackArraySize << '\n');
 

flang/lib/Optimizer/Transforms/RewriteLoop.cpp

public:
   }
 };
 
 /// Convert FIR structured control flow ops to CFG ops.
 class CfgConversion : public CFGConversionBase<CfgConversion> {
 public:
   void runOnOperation() override {
     auto *context = &getContext();
-    mlir::OwningRewritePatternList patterns(context);
+    mlir::RewritePatternSet patterns(context);
     patterns.insert<CfgLoopConv, CfgIfConv, CfgIterWhileConv>(
         context, forceLoopToExecuteOnce);
     mlir::ConversionTarget target(*context);
     target.addLegalDialect<mlir::AffineDialect, FIROpsDialect,
                            mlir::StandardOpsDialect>();
 
     // apply the patterns
     target.addIllegalOp<ResultOp, DoLoopOp, IfOp, IterWhileOp>();

mlir/include/mlir/Conversion/AffineToStandard/AffineToStandard.h

 struct LogicalResult;
 class OpBuilder;
 class Pass;
 class RewritePattern;
 class Value;
 class ValueRange;
 
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 /// Emit code that computes the given affine expression using standard
 /// arithmetic operations applied to the provided dimension and symbol values.
 Value expandAffineExpr(OpBuilder &builder, Location loc, AffineExpr expr,
                        ValueRange dimValues, ValueRange symbolValues);
 
 /// Create a sequence of operations that implement the `affineMap` applied to
 /// the given `operands` (as it it were an AffineApplyOp).

mlir/include/mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h

 
 class ConversionTarget;
 class ModuleOp;
 template <typename T>
 class OperationPass;
 class MLIRContext;
 class TypeConverter;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 /// Create a pass to convert Async operations to the LLVM dialect.
 std::unique_ptr<OperationPass<ModuleOp>> createConvertAsyncToLLVMPass();
 
 /// Populates patterns for async structural type conversions.
 ///
 /// A "structural" type conversion is one where the underlying ops are
 /// completely agnostic to the actual types involved and simply need to update

mlir/include/mlir/Conversion/GPUCommon/GPUCommonPass.h

 namespace mlir {
 
 class LLVMTypeConverter;
 class Location;
 struct LogicalResult;
 class ModuleOp;
 class Operation;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 template <typename T>
 class OperationPass;
 
 namespace gpu {
 class GPUModuleOp;
 } // namespace gpu
 

 /// This pass does not generate code to call GPU runtime APIs directly but
 /// instead uses a small wrapper library that exports a stable and conveniently
 /// typed ABI on top of GPU runtimes such as CUDA or ROCm (HIP).
 std::unique_ptr<OperationPass<ModuleOp>> createGpuToLLVMConversionPass();
 
 /// Collect a set of patterns to convert from the GPU dialect to LLVM and
 /// populate converter for gpu types.
 void populateGpuToLLVMConversionPatterns(LLVMTypeConverter &converter,
-                                         OwningRewritePatternList &patterns,
+                                         RewritePatternSet &patterns,
                                          StringRef gpuBinaryAnnotation = {});
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_GPUCOMMON_GPUCOMMONPASS_H_

mlir/include/mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h

 #include "mlir/Conversion/LLVMCommon/LoweringOptions.h"
 #include "mlir/Dialect/LLVMIR/LLVMTypes.h"
 #include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
 class ConversionTarget;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 template <typename OpT>
 class OperationPass;
 
 namespace gpu {
 class GPUModuleOp;
 class MMAMatrixType;
 } // namespace gpu

mlir/include/mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h

 #include "mlir/Conversion/GPUToROCDL/Runtimes.h"
 #include "mlir/Conversion/LLVMCommon/LoweringOptions.h"
 #include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
 class ConversionTarget;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 template <typename OpT>
 class OperationPass;
 
 namespace gpu {
 class GPUModuleOp;
 } // namespace gpu
 

mlir/include/mlir/Conversion/LinalgToSPIRV/LinalgToSPIRV.h

 
 #ifndef MLIR_CONVERSION_LINALGTOSPIRV_LINALGTOSPIRV_H
 #define MLIR_CONVERSION_LINALGTOSPIRV_LINALGTOSPIRV_H
 
 namespace mlir {
 class MLIRContext;
 class SPIRVTypeConverter;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 /// Appends to a pattern list additional patterns for translating Linalg ops to
 /// SPIR-V ops.
 void populateLinalgToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
                                    RewritePatternSet &patterns);
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_LINALGTOSPIRV_LINALGTOSPIRV_H

mlir/include/mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h

 
 namespace mlir {
 class LLVMTypeConverter;
 class MLIRContext;
 class ModuleOp;
 template <typename T>
 class OperationPass;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 /// Populate the given list with patterns that convert from OpenMP to LLVM.
 void populateOpenMPToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                             RewritePatternSet &patterns);
 
 /// Create a pass to convert OpenMP operations to the LLVMIR dialect.
 std::unique_ptr<OperationPass<ModuleOp>> createConvertOpenMPToLLVMPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_OPENMPTOLLVM_CONVERTOPENMPTOLLVM_H

mlir/include/mlir/Conversion/SCFToGPU/SCFToGPU.h

 namespace mlir {
 class AffineForOp;
 class ConversionTarget;
 struct LogicalResult;
 class MLIRContext;
 class Value;
 class Operation;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 namespace scf {
 class ForOp;
 } // namespace scf
 
 /// Convert a perfect affine loop nest with the outermost loop identified by
 /// `forOp` into a gpu::Launch operation.  Map `numBlockDims` outer loops to
 /// GPU blocks and `numThreadDims` to GPU threads.  The bounds of the loops that

mlir/include/mlir/Conversion/SCFToSPIRV/SCFToSPIRV.h

 
 namespace mlir {
 class Pass;
 
 // Owning list of rewriting patterns.
 class SPIRVTypeConverter;
 struct ScfToSPIRVContextImpl;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 struct ScfToSPIRVContext {
   ScfToSPIRVContext();
   ~ScfToSPIRVContext();
 
   ScfToSPIRVContextImpl *getImpl() { return impl.get(); }
 
 private:

mlir/include/mlir/Conversion/SCFToStandard/SCFToStandard.h

 #include <memory>
 #include <vector>
 
 namespace mlir {
 struct LogicalResult;
 class Pass;
 
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 /// Collect a set of patterns to lower from scf.for, scf.if, and
 /// loop.terminator to CFG operations within the Standard dialect, in particular
 /// convert structured control flow into CFG branch-based control flow.
 void populateLoopToStdConversionPatterns(RewritePatternSet &patterns);
 
 /// Creates a pass to convert scf.for, scf.if and loop.terminator ops to CFG.
 std::unique_ptr<Pass> createLowerToCFGPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_SCFTOSTANDARD_SCFTOSTANDARD_H_

mlir/include/mlir/Conversion/ShapeToStandard/ShapeToStandard.h

 
 namespace mlir {
 
 class FuncOp;
 class ModuleOp;
 template <typename T>
 class OperationPass;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 void populateShapeToStandardConversionPatterns(RewritePatternSet &patterns);
 
 std::unique_ptr<OperationPass<ModuleOp>> createConvertShapeToStandardPass();
 
 void populateConvertShapeConstraintsConversionPatterns(
     RewritePatternSet &patterns);
 
 std::unique_ptr<OperationPass<FuncOp>> createConvertShapeConstraintsPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_SHAPETOSTANDARD_SHAPETOSTANDARD_H_

mlir/include/mlir/Conversion/VectorToROCDL/VectorToROCDL.h

 #include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
 class ModuleOp;
 template <typename OpT>
 class OperationPass;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 /// Collect a set of patterns to convert from the GPU dialect to ROCDL.
 void populateVectorToROCDLConversionPatterns(LLVMTypeConverter &converter,
                                              RewritePatternSet &patterns);
 
 /// Create a pass to convert vector operations to the ROCDL dialect.
 std::unique_ptr<OperationPass<ModuleOp>> createConvertVectorToROCDLPass();
 
 } // namespace mlir
 #endif // MLIR_CONVERSION_VECTORTOROCDL_VECTORTOROCDL_H_

mlir/include/mlir/Dialect/AMX/Transforms.h

 //===- Transforms.h - AMX Dialect Transformation Entrypoints ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_AMX_TRANSFORMS_H
 #define MLIR_DIALECT_AMX_TRANSFORMS_H
 
 namespace mlir {
 
 class LLVMConversionTarget;
 class LLVMTypeConverter;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 /// Collect a set of patterns to lower AMX ops to ops that map to LLVM
 /// intrinsics.
 void populateAMXLegalizeForLLVMExportPatterns(LLVMTypeConverter &converter,
                                               RewritePatternSet &patterns);
 
 /// Configure the target to support lowering AMX ops to ops that map to LLVM
 /// intrinsics.
 void configureAMXLegalizeForExportTarget(LLVMConversionTarget &target);
 
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AMX_TRANSFORMS_H

mlir/include/mlir/Dialect/ArmSVE/Transforms.h

 //===- Transforms.h - ArmSVE Dialect Transformation Entrypoints -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_ARMSVE_TRANSFORMS_H
 #define MLIR_DIALECT_ARMSVE_TRANSFORMS_H
 
 namespace mlir {
 
 class LLVMConversionTarget;
 class LLVMTypeConverter;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 /// Collect a set of patterns to lower ArmSVE ops to ops that map to LLVM
 /// intrinsics.
 void populateArmSVELegalizeForLLVMExportPatterns(LLVMTypeConverter &converter,
                                                  RewritePatternSet &patterns);
 
 /// Configure the target to support lowering ArmSVE ops to ops that map to LLVM
 /// intrinsics.
 void configureArmSVELegalizeForExportTarget(LLVMConversionTarget &target);
 
 } // namespace mlir
 
 #endif // MLIR_DIALECT_ARMSVE_TRANSFORMS_H

mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h

 
 //===----------------------------------------------------------------------===//
 // Support for staged pattern application.
 //===----------------------------------------------------------------------===//
 /// Helper function to allow applying rewrite patterns, interleaved with more
 /// global transformations, in a staged fashion:
 ///   1. the first stage consists of a list of FrozenRewritePatternSet. Each
 ///   FrozenRewritePatternSet in this list is applied once, in order.
-///   2. the second stage consists of a single OwningRewritePattern that is
-///   applied greedily until convergence.
+///   2. the second stage consists of a single RewritePattern that is applied
+///      greedily until convergence.
 ///   3. the third stage consists of applying a lambda, generally used for
 ///   non-local transformation effects. This allows creating custom fused
 ///   transformations where patterns can be ordered and applied at a finer
 ///   granularity than a sequence of traditional compiler passes.
 LogicalResult applyStagedPatterns(
     Operation *op, ArrayRef<FrozenRewritePatternSet> stage1Patterns,
     const FrozenRewritePatternSet &stage2Patterns,
     function_ref<LogicalResult(Operation *)> stage3Lambda = nullptr);

mlir/include/mlir/Dialect/MemRef/Transforms/ComposeSubView.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_MEMREF_TRANSFORMS_COMPOSESUBVIEW_H_
 #define MLIR_DIALECT_MEMREF_TRANSFORMS_COMPOSESUBVIEW_H_
 
 namespace mlir {
 class MLIRContext;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 namespace memref {
 
-void populateComposeSubViewPatterns(OwningRewritePatternList &patterns,
+void populateComposeSubViewPatterns(RewritePatternSet &patterns,
                                     MLIRContext *context);
 
 } // namespace memref
 } // namespace mlir
 
 #endif // MLIR_DIALECT_MEMREF_TRANSFORMS_COMPOSESUBVIEW_H_

mlir/include/mlir/Dialect/SCF/Transforms.h

 class AffineMap;
 class ConversionTarget;
 struct LogicalResult;
 class MLIRContext;
 class Region;
 class RewriterBase;
 class TypeConverter;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 class Operation;
 class Value;
 class ValueRange;
 
 namespace scf {
 
 class IfOp;
 class ForOp;

mlir/include/mlir/Dialect/StandardOps/Transforms/FuncConversions.h

 
 // Forward declarations.
 class BranchOpInterface;
 class ConversionTarget;
 class MLIRContext;
 class Operation;
 class TypeConverter;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 /// Add a pattern to the given pattern list to convert the operand and result
 /// types of a CallOp with the given type converter.
 void populateCallOpTypeConversionPattern(RewritePatternSet &patterns,
                                          TypeConverter &converter);
 
 /// Add a pattern to the given pattern list to rewrite branch operations to use
 /// operands that have been legalized by the conversion framework. This can only

mlir/include/mlir/Dialect/StandardOps/Transforms/Passes.h

 
 namespace mlir {
 namespace bufferization {
 class BufferizeTypeConverter;
 class GlobalCreator;
 } // namespace bufferization
 
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 void populateStdBufferizePatterns(
     bufferization::BufferizeTypeConverter &typeConverter,
     RewritePatternSet &patterns);
 
 /// Creates an instance of std bufferization pass.
 std::unique_ptr<Pass> createStdBufferizePass();
 

mlir/include/mlir/Dialect/Tensor/Transforms/Passes.h

 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 namespace bufferization {
 class BufferizeTypeConverter;
 } // namespace bufferization
 
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 void populateTensorBufferizePatterns(
     bufferization::BufferizeTypeConverter &typeConverter,
     RewritePatternSet &patterns);
 
 /// Creates an instance of `tensor` dialect bufferization pass.
 std::unique_ptr<Pass> createTensorBufferizePass();
 

mlir/include/mlir/Dialect/Vector/VectorOps.h

 #include "llvm/ADT/StringExtras.h"
 
 // Pull in all enum type definitions and utility function declarations.
 #include "mlir/Dialect/Vector/VectorOpsEnums.h.inc"
 
 namespace mlir {
 class MLIRContext;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 namespace vector {
 class VectorDialect;
 
 namespace detail {
 struct BitmaskEnumStorage;
 } // namespace detail
 

mlir/include/mlir/Dialect/Vector/VectorTransforms.h

 #include "mlir/Dialect/Vector/VectorUtils.h"
 
 namespace mlir {
 class MLIRContext;
 class VectorTransferOpInterface;
 class RewritePatternSet;
 class RewriterBase;
 
-using OwningRewritePatternList = RewritePatternSet;
-
 namespace scf {
 class IfOp;
 } // namespace scf
 
 namespace vector {
 
 //===----------------------------------------------------------------------===//
 // Standalone transformations and helpers.

mlir/include/mlir/Dialect/X86Vector/Transforms.h

 #include "mlir/IR/Value.h"
 
 namespace mlir {
 
 class ImplicitLocOpBuilder;
 class LLVMConversionTarget;
 class LLVMTypeConverter;
 class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
 
 namespace x86vector {
 
 /// Helper class to factor out the creation and extraction of masks from nibs.
 struct MaskHelper {
   /// b0 captures the lowest bit, b7 captures the highest bit.
   /// Meant to be used with instructions such as mm256BlendPs.
   template <uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3, uint8_t b4,

mlir/include/mlir/IR/OperationSupport.h

 class OperandRange;
 class OperandRangeRange;
 class OpFoldResult;
 class ParseResult;
 class Pattern;
 class Region;
 class ResultRange;
 class RewritePattern;
+class RewritePatternSet;
 class Type;
 class Value;
 class ValueRange;
 template <typename ValueRangeT>
 class ValueTypeRange;
 
-class RewritePatternSet;
-using OwningRewritePatternList = RewritePatternSet;
-
 //===----------------------------------------------------------------------===//
 // OperationName
 //===----------------------------------------------------------------------===//
 
 class OperationName {
 public:
   using GetCanonicalizationPatternsFn =
       llvm::unique_function<void(RewritePatternSet &, MLIRContext *) const>;

mlir/lib/Conversion/GPUCommon/GPUToLLVMConversion.cpp

 }
 
 std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
 mlir::createGpuToLLVMConversionPass() {
   return std::make_unique<GpuToLLVMConversionPass>();
 }
 
 void mlir::populateGpuToLLVMConversionPatterns(
-    LLVMTypeConverter &converter, OwningRewritePatternList &patterns,
+    LLVMTypeConverter &converter, RewritePatternSet &patterns,
     StringRef gpuBinaryAnnotation) {
   converter.addConversion(
       [context = &converter.getContext()](gpu::AsyncTokenType type) -> Type {
         return LLVM::LLVMPointerType::get(IntegerType::get(context, 8));
       });
   patterns.add<ConvertAllocOpToGpuRuntimeCallPattern,
                ConvertDeallocOpToGpuRuntimeCallPattern,
                ConvertHostRegisterOpToGpuRuntimeCallPattern,

mlir/lib/Conversion/OpenACCToLLVM/OpenACCToLLVM.cpp

builder.replaceOpWithNewOp<Op>(op, TypeRange(), convertedOperands,
                                    op.getOperation()->getAttrs());
 
     return success();
   }
 };
 } // namespace
 
 void mlir::populateOpenACCToLLVMConversionPatterns(
-    LLVMTypeConverter &converter, OwningRewritePatternList &patterns) {
+    LLVMTypeConverter &converter, RewritePatternSet &patterns) {
   patterns.add<LegalizeDataOpForLLVMTranslation<acc::DataOp>>(converter);
   patterns.add<LegalizeDataOpForLLVMTranslation<acc::EnterDataOp>>(converter);
   patterns.add<LegalizeDataOpForLLVMTranslation<acc::ExitDataOp>>(converter);
   patterns.add<LegalizeDataOpForLLVMTranslation<acc::ParallelOp>>(converter);
   patterns.add<LegalizeDataOpForLLVMTranslation<acc::UpdateOp>>(converter);
 }
 
 namespace {

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

if (auto sub = getRhs().getDefiningOp<SubIOp>())
     if (getLhs() == sub.getRhs())
       return sub.getLhs();
 
   return constFoldBinaryOp<IntegerAttr>(
       operands, [](APInt a, const APInt &b) { return std::move(a) + b; });
 }
 
 void arith::AddIOp::getCanonicalizationPatterns(
-    OwningRewritePatternList &patterns, MLIRContext *context) {
+    RewritePatternSet &patterns, MLIRContext *context) {
   patterns.insert<AddIAddConstant, AddISubConstantRHS, AddISubConstantLHS>(
       context);
 }
 
 //===----------------------------------------------------------------------===//
 // SubIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::SubIOp::fold(ArrayRef<Attribute> operands) {
   // subi(x,x) -> 0
   if (getOperand(0) == getOperand(1))
     return Builder(getContext()).getZeroAttr(getType());
   // subi(x,0) -> x
   if (matchPattern(getRhs(), m_Zero()))
     return getLhs();
 
   return constFoldBinaryOp<IntegerAttr>(
       operands, [](APInt a, const APInt &b) { return std::move(a) - b; });
 }
 
 void arith::SubIOp::getCanonicalizationPatterns(
-    OwningRewritePatternList &patterns, MLIRContext *context) {
+    RewritePatternSet &patterns, MLIRContext *context) {
   patterns.insert<SubIRHSAddConstant, SubILHSAddConstant, SubIRHSSubConstantRHS,
                   SubIRHSSubConstantLHS, SubILHSSubConstantRHS,
                   SubILHSSubConstantLHS>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // MulIOp
 //===----------------------------------------------------------------------===//
if (arith::XOrIOp prev = getLhs().getDefiningOp<arith::XOrIOp>())
     if (prev.getRhs() == getRhs())
       return prev.getLhs();
 
   return constFoldBinaryOp<IntegerAttr>(
       operands, [](APInt a, const APInt &b) { return std::move(a) ^ b; });
 }
 
 void arith::XOrIOp::getCanonicalizationPatterns(
-    OwningRewritePatternList &patterns, MLIRContext *context) {
+    RewritePatternSet &patterns, MLIRContext *context) {
   patterns.insert<XOrINotCmpI>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // AddFOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::AddFOp::fold(ArrayRef<Attribute> operands) {
OpFoldResult arith::ExtSIOp::fold(ArrayRef<Attribute> operands) {
   return {};
 }
 
 bool arith::ExtSIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return checkWidthChangeCast<std::greater, IntegerType>(inputs, outputs);
 }
 
 void arith::ExtSIOp::getCanonicalizationPatterns(
-    OwningRewritePatternList &patterns, MLIRContext *context) {
+    RewritePatternSet &patterns, MLIRContext *context) {
   patterns.insert<ExtSIOfExtUI>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // ExtFOp
 //===----------------------------------------------------------------------===//
 
 bool arith::ExtFOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
bool arith::TruncFOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return checkWidthChangeCast<std::less, FloatType>(inputs, outputs);
 }
 
 //===----------------------------------------------------------------------===//
 // AndIOp
 //===----------------------------------------------------------------------===//
 
 void arith::AndIOp::getCanonicalizationPatterns(
-    OwningRewritePatternList &patterns, MLIRContext *context) {
+    RewritePatternSet &patterns, MLIRContext *context) {
   patterns.insert<AndOfExtUI, AndOfExtSI>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // OrIOp
 //===----------------------------------------------------------------------===//
 
 void arith::OrIOp::getCanonicalizationPatterns(
-    OwningRewritePatternList &patterns, MLIRContext *context) {
+    RewritePatternSet &patterns, MLIRContext *context) {
   patterns.insert<OrOfExtUI, OrOfExtSI>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // Verifiers for casts between integers and floats.
 //===----------------------------------------------------------------------===//
 
 template <typename From, typename To>
OpFoldResult arith::IndexCastOp::fold(ArrayRef<Attribute> operands) {
   // constant might need to change.
   if (auto value = operands[0].dyn_cast_or_null<IntegerAttr>())
     return IntegerAttr::get(getType(), value.getInt());
 
   return {};
 }
 
 void arith::IndexCastOp::getCanonicalizationPatterns(
-    OwningRewritePatternList &patterns, MLIRContext *context) {
+    RewritePatternSet &patterns, MLIRContext *context) {
   patterns.insert<IndexCastOfIndexCast, IndexCastOfExtSI>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // BitcastOp
 //===----------------------------------------------------------------------===//
 
 bool arith::BitcastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
OpFoldResult arith::BitcastOp::fold(ArrayRef<Attribute> operands) {
 
   if (auto resFloatType = resType.dyn_cast<FloatType>())
     return FloatAttr::get(resType,
                           APFloat(resFloatType.getFloatSemantics(), bits));
   return IntegerAttr::get(resType, bits);
 }
 
 void arith::BitcastOp::getCanonicalizationPatterns(
-    OwningRewritePatternList &patterns, MLIRContext *context) {
+    RewritePatternSet &patterns, MLIRContext *context) {
   patterns.insert<BitcastOfBitcast>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // Helpers for compare ops
 //===----------------------------------------------------------------------===//
 
 /// Return the type of the same shape (scalar, vector or tensor) containing i1.

mlir/lib/Dialect/ArmSVE/Transforms/LegalizeForLLVMExport.cpp

using ScalableMaskedUDivIOpLowering =
     OneToOneConvertToLLVMPattern<ScalableMaskedUDivIOp,
                                  ScalableMaskedUDivIIntrOp>;
 using ScalableMaskedDivFOpLowering =
     OneToOneConvertToLLVMPattern<ScalableMaskedDivFOp,
                                  ScalableMaskedDivFIntrOp>;
 
 /// Populate the given list with patterns that convert from ArmSVE to LLVM.
 void mlir::populateArmSVELegalizeForLLVMExportPatterns(
-    LLVMTypeConverter &converter, OwningRewritePatternList &patterns) {
+    LLVMTypeConverter &converter, RewritePatternSet &patterns) {
   // Populate conversion patterns
 
   // clang-format off
   patterns.add<ForwardOperands<CallOp>,
                ForwardOperands<CallIndirectOp>,
                ForwardOperands<ReturnOp>>(converter,
                                           &converter.getContext());
   patterns.add<SdotOpLowering,

mlir/lib/Dialect/Bufferization/IR/BufferizationOps.cpp

rewriter.replaceOpWithNewOp<memref::CastOp>(cloneOp, cloneOp.getType(),
                                                 source);
     rewriter.eraseOp(redundantDealloc);
     return success();
   }
 };
 
 } // namespace
 
-void CloneOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+void CloneOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                           MLIRContext *context) {
   results.insert<SimplifyClones>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // ToTensorOp
 //===----------------------------------------------------------------------===//
 

mlir/lib/Dialect/Bufferization/Transforms/Bufferize.cpp

checkBufferizationResult(Operation *op, const BufferizationOptions &options) {
   }
 
   return success();
 }
 
 LogicalResult bufferization::bufferizeOp(Operation *op,
                                          const BufferizationState &state) {
   // Bufferize the op and its nested ops.
-  OwningRewritePatternList patterns(op->getContext());
+  RewritePatternSet patterns(op->getContext());
   patterns.add<BufferizationPattern>(op->getContext(), state);
   if (failed(applyPatternsAndFoldGreedily(op, std::move(patterns))))
     return failure();
 
   return checkBufferizationResult(op, state.getOptions());
 }

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

for (const auto &en : llvm::enumerate(oldResultIdToNew))
         resultReplacement[en.index()] = newTiledLoop.getResult(en.value());
     rewriter.replaceOp(tiledLoop, resultReplacement);
 
     return success();
   }
 };
 } // namespace
 
-void TiledLoopOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+void TiledLoopOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                               MLIRContext *context) {
   results.insert<TiledLoopInputsFolder, TiledLoopResultsFolder,
                  DimOfTiledLoopInsOutsFolder<tensor::DimOp>,
                  DimOfTiledLoopInsOutsFolder<memref::DimOp>,
                  DimOfTiledLoopResultFolder<tensor::DimOp>,
                  DimOfTiledLoopResultFolder<memref::DimOp>>(context);
 }
 

mlir/lib/Dialect/MemRef/Transforms/ComposeSubView.cpp

rewriter.replaceOpWithNewOp<memref::SubViewOp>(op, sourceOp.source(),
                                                    offsets, sizes, strides);
     return success();
   }
 };
 
 } // namespace
 
 void mlir::memref::populateComposeSubViewPatterns(
-    OwningRewritePatternList &patterns, MLIRContext *context) {
+    RewritePatternSet &patterns, MLIRContext *context) {
   patterns.insert<ComposeSubViewOpPattern>(context);
 }

mlir/lib/Dialect/SCF/SCF.cpp

LogicalResult matchAndRewrite(WhileOp op,
 
     rewriter.setInsertionPoint(yield);
     rewriter.replaceOpWithNewOp<YieldOp>(yield, newYields);
     return success();
   }
 };
 } // namespace
 
-void WhileOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+void WhileOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                           MLIRContext *context) {
   results.insert<WhileConditionTruth, WhileUnusedResult, WhileCmpCond,
                  WhileUnusedArg>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/SCF/SCFOps.cpp.inc"

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

if (matchPattern(op.getTrueValue(), m_Zero()))
                     op.getLoc(), 1, op.getCondition().getType())));
         return success();
       }
 
     return failure();
   }
 };
 
-void SelectOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+void SelectOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                            MLIRContext *context) {
   results.insert<SelectI1Simplify, SelectToExtUI>(context);
 }
 
 OpFoldResult SelectOp::fold(ArrayRef<Attribute> operands) {
   auto trueVal = getTrueValue();
   auto falseVal = getFalseValue();
   if (trueVal == falseVal)

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

if (op.input1().front().getType() != op.getType()) {
       return success();
     }
 
     rewriter.replaceOp(op, op.input1().front());
     return success();
   }
 };
 
-void ConcatOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+void ConcatOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                            MLIRContext *context) {
   results.insert<ConcatOptimization>(context);
 }
 
 struct ReshapeReshapeOptimization : public OpRewritePattern<tosa::ReshapeOp> {
   using OpRewritePattern<tosa::ReshapeOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::ReshapeOp op,
LogicalResult matchAndRewrite(tosa::ReshapeOp op,
     DenseElementsAttr outputAttr =
         inputAttr.reshape(inputShape.clone(newShapeValues));
     rewriter.replaceOpWithNewOp<tosa::ConstOp>(op, outputAttr.getType(),
                                                outputAttr);
     return success();
   }
 };
 
-void ReshapeOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+void ReshapeOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                             MLIRContext *context) {
   results.insert<ReshapeReshapeOptimization>(context);
   results.insert<ReshapeConstOptimization>(context);
 }
 
 struct ConstantTransposeOptimization
     : public OpRewritePattern<tosa::TransposeOp> {
   using OpRewritePattern::OpRewritePattern;
for (int i = 0, s = permValues.size(); i < s; i++) {
       }
     }
 
     rewriter.replaceOp(op, op.input1());
     return success();
   }
 };
 
-void TransposeOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+void TransposeOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                               MLIRContext *context) {
   results.insert<ConstantTransposeOptimization>(context);
   results.insert<NoOpOptimization>(context);
 }
 
 struct AddZeroOptimization : public OpRewritePattern<tosa::AddOp> {
   using OpRewritePattern::OpRewritePattern;
 
if (matchPattern(input2, m_Constant(&input2Attr)) && input2Attr.isSplat() &&
         return success();
       }
     }
 
     return failure();
   }
 };
 
-void AddOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+void AddOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                         MLIRContext *context) {
   results.insert<AddZeroOptimization>(context);
 }
 
 struct MulOneOptimization : public OpRewritePattern<tosa::MulOp> {
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::MulOp op,
if (matchPattern(input2, m_Constant(&input2Attr)) && input2Attr.isSplat() &&
         return success();
       }
     }
 
     return failure();
   }
 };
 
-void MulOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+void MulOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                         MLIRContext *context) {
   results.insert<MulOneOptimization>(context);
 }
 
 struct MaterializePadValue : public OpRewritePattern<tosa::PadOp> {
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::PadOp op,
LogicalResult matchAndRewrite(tosa::PadOp op,
 
     rewriter.replaceOpWithNewOp<tosa::PadOp>(
         op, op.getType(), ValueRange{input, padding, constantVal},
         op->getAttrs());
     return success();
   }
 };
 
-void PadOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+void PadOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                         MLIRContext *context) {
   results.insert<MaterializePadValue>(context);
 }
 
 struct MaxPool2dIsNoOp : public OpRewritePattern<tosa::MaxPool2dOp> {
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::MaxPool2dOp op,
if (inputShape[1] != 1 || inputShape[2] != 1) {
       return failure();
     }
 
     rewriter.replaceOp(op, input);
     return success();
   }
 };
 
-void MaxPool2dOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+void MaxPool2dOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                               MLIRContext *context) {
   results.insert<MaxPool2dIsNoOp>(context);
 }
 
 struct ClampIsNoOp : public OpRewritePattern<tosa::ClampOp> {
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::ClampOp op,
if (tosa::ClampOp clampOp = dyn_cast<tosa::ClampOp>(definingOp)) {
           rewriter.getF32FloatAttr(max_fp));
       return success();
     }
 
     return failure();
   }
 };
 
-void ClampOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+void ClampOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                           MLIRContext *context) {
   results.insert<ClampIsNoOp>(context);
   results.insert<ClampClampOptimization>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // Operator Folders.
 //===----------------------------------------------------------------------===//

mlir/test/lib/Dialect/Linalg/TestLinalgDistribution.cpp

struct TestLinalgDistribution
   }
 
   void runOnOperation() override;
 };
 } // namespace
 
 void TestLinalgDistribution::runOnOperation() {
   auto funcOp = getOperation();
-  OwningRewritePatternList distributeTiledLoopsPatterns(&getContext());
+  RewritePatternSet distributeTiledLoopsPatterns(&getContext());
   populateLinalgDistributeTiledLoopPattern(
       distributeTiledLoopsPatterns, getDistributionOptions(),
       LinalgTransformationFilter(
           ArrayRef<StringAttr>{},
           {StringAttr::get(funcOp.getContext(), "distributed")})
           .addFilter([](Operation *op) {
             return success(!op->getParentOfType<linalg::TiledLoopOp>());
           }));

mlir/test/lib/Dialect/MemRef/TestComposeSubView.cpp

 };
 
 void TestComposeSubViewPass::getDependentDialects(
     DialectRegistry &registry) const {
   registry.insert<AffineDialect>();
 }
 
 void TestComposeSubViewPass::runOnOperation() {
-  OwningRewritePatternList patterns(&getContext());
+  RewritePatternSet patterns(&getContext());
   memref::populateComposeSubViewPatterns(patterns, &getContext());
   (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 }
 } // namespace
 
 namespace mlir {
 namespace test {
 void registerTestComposeSubView() {
   PassRegistration<TestComposeSubViewPass>();
 }
 } // namespace test
 } // namespace mlir