[PatternRewriter] Rename OwningRewritePatternList -> RewritePatternSet and insert -> add

[lattner]

Summary

This maintains the old name to have minimal source impact on downstream codes, and
does not do the huge mechanical patch. I expect the huge mechanical patch to land
sometime this week, but we can keep around the old names for a couple weeks to reduce
impact on downstream projects.

[rriddle]

LGTM, Thanks!

mlir/include/mlir/IR/PatternMatch.h

755

Did you mean for this Note to be here?

899

Can you add a TODO or something here? Just so that the fact it is temporary doesn't get lost.

mlir/lib/Dialect/Math/Transforms/ExpandTanh.cpp

55

Was this change intended to be in the next one (the one that starts doing the renaming)?

[stellaraccident]

Thank you for staging the change in this way. It does make such O(codebase) downstream work easier (and reduces bisectability barriers that show up with breaking API changes).

[lattner]

mlir/include/mlir/IR/PatternMatch.h

755

Nope, this one was a mistake, great catch.

899

Good point,done.

mlir/lib/Dialect/Math/Transforms/ExpandTanh.cpp

55

Yeah it was intentional, my thought was to include one change in this patch to show that it works.

[lattner]

Improve some comments that River caught.

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

 class Location;
 struct LogicalResult;
 class OpBuilder;
 class Pass;
 class RewritePattern;
 class Value;
 class ValueRange;
 
-// Owning list of rewriting patterns.
-class OwningRewritePatternList;
+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/ArmSVEToLLVM/ArmSVEToLLVM.h

 //===- ArmSVEToLLVM.h - Conversion Patterns from ArmSVE to LLVM -----------===//
 //
 // 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_CONVERSION_ARMSVETOLLVM_ARMSVETOLLVM_H_
 #define MLIR_CONVERSION_ARMSVETOLLVM_ARMSVETOLLVM_H_
 
 namespace mlir {
 
 class LLVMTypeConverter;
-class OwningRewritePatternList;
+class RewritePatternSet;
+using OwningRewritePatternList = RewritePatternSet;
 
 /// Collect a set of patterns to convert from the ArmSVE dialect to LLVM.
 void populateArmSVEToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                             OwningRewritePatternList &patterns);
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_ARMSVETOLLVM_ARMSVETOLLVM_H_

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

 
 namespace mlir {
 
 class ConversionTarget;
 class ModuleOp;
 template <typename T>
 class OperationPass;
 class MLIRContext;
-class OwningRewritePatternList;
 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 OwningRewritePatternList;
+class RewritePatternSet;
+using OwningRewritePatternList = RewritePatternSet;
 
 template <typename T>
 class OperationPass;
 
 namespace gpu {
 class GPUModuleOp;
 } // namespace gpu
 

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

 //===- GPUToNVVMPass.h - Convert GPU kernel to NVVM dialect -----*- 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_CONVERSION_GPUTONVVM_GPUTONVVMPASS_H_
 #define MLIR_CONVERSION_GPUTONVVM_GPUTONVVMPASS_H_
 
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
-class OwningRewritePatternList;
 class ConversionTarget;
+class RewritePatternSet;
+using OwningRewritePatternList = RewritePatternSet;
 
-template <typename OpT> class OperationPass;
+template <typename OpT>
+class OperationPass;
 
 namespace gpu {
 class GPUModuleOp;
 }
 
 /// Configure target to convert from the GPU dialect to NVVM.
 void configureGpuToNVVMConversionLegality(ConversionTarget &target);
 

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

 //===- GPUToROCDLPass.h - Convert GPU kernel to ROCDL dialect ---*- 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_CONVERSION_GPUTOROCDL_GPUTOROCDLPASS_H_
 #define MLIR_CONVERSION_GPUTOROCDL_GPUTOROCDLPASS_H_
 
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
-class OwningRewritePatternList;
 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 OwningRewritePatternList;
 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,
                                    OwningRewritePatternList &patterns);
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_LINALGTOSPIRV_LINALGTOSPIRV_H

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

 //===- OpenMPToLLVM.h - Utils to convert from the OpenMP dialect ----------===//
 //
 // 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_CONVERSION_OPENMPTOLLVM_OPENMPTOLLVM_H_
 #define MLIR_CONVERSION_OPENMPTOLLVM_OPENMPTOLLVM_H_
 
-#include<memory>
+#include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
 class MLIRContext;
 class ModuleOp;
 template <typename T>
 class OperationPass;
-class OwningRewritePatternList;
+class RewritePatternSet;
+using OwningRewritePatternList = RewritePatternSet;
 
 /// Populate the given list with patterns that convert from OpenMP to LLVM.
 void populateOpenMPToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                             OwningRewritePatternList &patterns);
 
 /// Create a pass to convert OpenMP operations to the LLVMIR dialect.
 std::unique_ptr<OperationPass<ModuleOp>> createConvertOpenMPToLLVMPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_OPENMPTOLLVM_OPENMPTOLLVM_H_

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

 
 #include "mlir/Support/LLVM.h"
 
 namespace mlir {
 class AffineForOp;
 class ConversionTarget;
 struct LogicalResult;
 class MLIRContext;
-class OwningRewritePatternList;
 class Value;
+class RewritePatternSet;
+using OwningRewritePatternList = RewritePatternSet;
 
 namespace scf {
 class ForOp;
 } // end 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

 #define MLIR_CONVERSION_SCFTOSPIRV_SCFTOSPIRV_H_
 
 #include <memory>
 
 namespace mlir {
 class Pass;
 
 // Owning list of rewriting patterns.
-class OwningRewritePatternList;
 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

 #define MLIR_CONVERSION_SCFTOSTANDARD_SCFTOSTANDARD_H_
 
 #include <memory>
 #include <vector>
 
 namespace mlir {
 struct LogicalResult;
 class Pass;
-class RewritePattern;
 
-// Owning list of rewriting patterns.
-class OwningRewritePatternList;
+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(OwningRewritePatternList &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

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

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h

 
 #include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
 class ModuleOp;
 template <typename T>
 class OperationPass;
-class OwningRewritePatternList;
+class RewritePatternSet;
+using OwningRewritePatternList = RewritePatternSet;
 
 /// Value to pass as bitwidth for the index type when the converter is expected
 /// to derive the bitwidth from the LLVM data layout.
 static constexpr unsigned kDeriveIndexBitwidthFromDataLayout = 0;
 
 /// Options to control the Standard dialect to LLVM lowering. The struct is used
 /// to share lowering options between passes, patterns, and type converter.
 struct LowerToLLVMOptions {

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

 //===- VectorToROCDL.h - Convert Vector to ROCDL dialect ---*- 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_CONVERSION_VECTORTOROCDL_VECTORTOROCDL_H_
 #define MLIR_CONVERSION_VECTORTOROCDL_VECTORTOROCDL_H_
 
 #include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
-class OwningRewritePatternList;
 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, OwningRewritePatternList &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/Conversion/VectorToSCF/VectorToSCF.h

 //===- VectorToSCF.h - Utils to convert from the vector dialect -*- 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_CONVERSION_VECTORTOSCF_VECTORTOSCF_H_
 #define MLIR_CONVERSION_VECTORTOSCF_VECTORTOSCF_H_
 
 #include "mlir/IR/PatternMatch.h"
 
 namespace mlir {
 class MLIRContext;
-class OwningRewritePatternList;
 class Pass;
+class RewritePatternSet;
+using OwningRewritePatternList = RewritePatternSet;
 
 /// Control whether unrolling is used when lowering vector transfer ops to SCF.
 ///
 /// Case 1:
 /// =======
 /// When `unroll` is false, a temporary buffer is created through which
 /// individual 1-D vector are staged. this is consistent with the lack of an
 /// LLVM instruction to dynamically index into an aggregate (see the Vector

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 OwningRewritePatternList;
+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, OwningRewritePatternList &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/AVX512/Transforms.h

 //===- Transforms.h - AVX512 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_AVX512_TRANSFORMS_H
 #define MLIR_DIALECT_AVX512_TRANSFORMS_H
 
 namespace mlir {
 
 class LLVMConversionTarget;
 class LLVMTypeConverter;
-class OwningRewritePatternList;
+class RewritePatternSet;
+using OwningRewritePatternList = RewritePatternSet;
 
 /// Collect a set of patterns to lower AVX512 ops to ops that map to LLVM
 /// intrinsics.
 void populateAVX512LegalizeForLLVMExportPatterns(
     LLVMTypeConverter &converter, OwningRewritePatternList &patterns);
 
 /// Configure the target to support lowering AVX512 ops to ops that map to LLVM
 /// intrinsics.
 void configureAVX512LegalizeForExportTarget(LLVMConversionTarget &target);
 
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AVX512_TRANSFORMS_H

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

 //===- Passes.h - Pass 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_MATH_TRANSFORMS_PASSES_H_
 #define MLIR_DIALECT_MATH_TRANSFORMS_PASSES_H_
 
 namespace mlir {
 
-class OwningRewritePatternList;
+class RewritePatternSet;
 
-void populateExpandTanhPattern(OwningRewritePatternList &patterns);
+void populateExpandTanhPattern(RewritePatternSet &patterns);
 
-void populateMathPolynomialApproximationPatterns(
-    OwningRewritePatternList &patterns);
+void populateMathPolynomialApproximationPatterns(RewritePatternSet &patterns);
 
 } // namespace mlir
 
 #endif // MLIR_DIALECT_MATH_TRANSFORMS_PASSES_H_

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

 #define MLIR_DIALECT_SCF_TRANSFORMS_H_
 
 #include "llvm/ADT/ArrayRef.h"
 
 namespace mlir {
 
 class ConversionTarget;
 class MLIRContext;
-class OwningRewritePatternList;
 class Region;
 class TypeConverter;
+class RewritePatternSet;
+using OwningRewritePatternList = RewritePatternSet;
 
 namespace scf {
 
 class ParallelOp;
 
 /// Fuses all adjacent scf.parallel operations with identical bounds and step
 /// into one scf.parallel operations. Uses a naive aliasing and dependency
 /// analysis.

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

 #define MLIR_DIALECT_STANDARDOPS_TRANSFORMS_FUNCCONVERSIONS_H_
 
 namespace mlir {
 
 // Forward declarations.
 class ConversionTarget;
 class MLIRContext;
 class Operation;
-class OwningRewritePatternList;
 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(OwningRewritePatternList &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

 #ifndef MLIR_DIALECT_STANDARD_TRANSFORMS_PASSES_H_
 #define MLIR_DIALECT_STANDARD_TRANSFORMS_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/Bufferize.h"
 
 namespace mlir {
 
-class OwningRewritePatternList;
+class RewritePatternSet;
+using OwningRewritePatternList = RewritePatternSet;
 
 void populateStdBufferizePatterns(BufferizeTypeConverter &typeConverter,
                                   OwningRewritePatternList &patterns);
 
 /// Creates an instance of std bufferization pass.
 std::unique_ptr<Pass> createStdBufferizePass();
 
 /// Creates an instance of func bufferization pass.

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

 //===- Passes.h - Pass 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_TENSOR_TRANSFORMS_PASSES_H_
 #define MLIR_DIALECT_TENSOR_TRANSFORMS_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/Bufferize.h"
 
 namespace mlir {
 
-class OwningRewritePatternList;
+class RewritePatternSet;
+using OwningRewritePatternList = RewritePatternSet;
 
 void populateTensorBufferizePatterns(BufferizeTypeConverter &typeConverter,
                                      OwningRewritePatternList &patterns);
 
 /// Creates an instance of `tensor` dialect bufferization pass.
 std::unique_ptr<Pass> createTensorBufferizePass();
 
 //===----------------------------------------------------------------------===//

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

 #include "mlir/Interfaces/ViewLikeInterface.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 OwningRewritePatternList;
+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/VectorOps.h"
 #include "mlir/Dialect/Vector/VectorUtils.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/PatternMatch.h"
 
 namespace mlir {
 class MLIRContext;
-class OwningRewritePatternList;
 class VectorTransferOpInterface;
+class RewritePatternSet;
+using OwningRewritePatternList = RewritePatternSet;
 
 namespace scf {
 class IfOp;
 } // namespace scf
 
 /// Collect a set of patterns to convert from the Vector dialect to itself.
 /// Should be merged with populateVectorToSCFLoweringPattern.
 void populateVectorToVectorConversionPatterns(

mlir/include/mlir/IR/OperationSupport.h

 class ParseResult;
 class Pattern;
 class Region;
 class ResultRange;
 class RewritePattern;
 class Type;
 class Value;
 class ValueRange;
-template <typename ValueRangeT> class ValueTypeRange;
+template <typename ValueRangeT>
+class ValueTypeRange;
 
-class OwningRewritePatternList;
+class RewritePatternSet;
+using OwningRewritePatternList = RewritePatternSet;
 
 //===----------------------------------------------------------------------===//
 // AbstractOperation
 //===----------------------------------------------------------------------===//
 
 /// This is a "type erased" representation of a registered operation.  This
 /// should only be used by things like the AsmPrinter and other things that need
 /// to be parameterized by generic operation hooks.  Most user code should use
public:
   void getCanonicalizationPatterns(OwningRewritePatternList &results,
                                    MLIRContext *context) const {
     return getCanonicalizationPatternsFn(results, context);
   }
 
   /// Returns an instance of the concept object for the given interface if it
   /// was registered to this operation, null otherwise. This should not be used
   /// directly.
-  template <typename T> typename T::Concept *getInterface() const {
+  template <typename T>
+  typename T::Concept *getInterface() const {
     return interfaceMap.lookup<T>();
   }
 
   /// Returns true if the operation has a particular trait.
-  template <template <typename T> class Trait> bool hasTrait() const {
+  template <template <typename T> class Trait>
+  bool hasTrait() const {
     return hasTraitFn(TypeID::get<Trait>());
   }
 
   /// Look up the specified operation in the specified MLIRContext and return a
   /// pointer to it if present.  Otherwise, return a null pointer.
   static const AbstractOperation *lookup(StringRef opName,
                                          MLIRContext *context);
 
   /// This constructor is used by Dialect objects when they register the list of
   /// operations they contain.
-  template <typename T> static void insert(Dialect &dialect) {
+  template <typename T>
+  static void insert(Dialect &dialect) {
     insert(T::getOperationName(), dialect, TypeID::get<T>(),
            T::getParseAssemblyFn(), T::getPrintAssemblyFn(),
            T::getVerifyInvariantsFn(), T::getFoldHookFn(),
            T::getGetCanonicalizationPatternsFn(), T::getInterfaceMap(),
            T::getHasTraitFn());
   }
 
 private:
public:
   void append(Identifier name, Attribute attr) {
     append(NamedAttribute(name, attr));
   }
 
   /// Append the given named attribute.
   void append(NamedAttribute attr) { push_back(attr); }
 
   /// Add an array of named attributes.
-  template <typename RangeT> void append(RangeT &&newAttributes) {
+  template <typename RangeT>
+  void append(RangeT &&newAttributes) {
     append(std::begin(newAttributes), std::end(newAttributes));
   }
 
   /// Add a range of named attributes.
   template <typename IteratorT>
   void append(IteratorT in_start, IteratorT in_end) {
     // TODO: expand to handle case where values appended are in order & after
     // end of current list.

 
 /// Enable Bitmask enums for OperationEquivalence::Flags.
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
 } // end namespace mlir
 
 namespace llvm {
 // Identifiers hash just like pointers, there is no need to hash the bytes.
-template <> struct DenseMapInfo<mlir::OperationName> {
+template <>
+struct DenseMapInfo<mlir::OperationName> {
   static mlir::OperationName getEmptyKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::OperationName::getFromOpaquePointer(pointer);
   }
   static mlir::OperationName getTombstoneKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return mlir::OperationName::getFromOpaquePointer(pointer);
   }
   static unsigned getHashValue(mlir::OperationName Val) {
     return DenseMapInfo<void *>::getHashValue(Val.getAsOpaquePointer());
   }
   static bool isEqual(mlir::OperationName LHS, mlir::OperationName RHS) {
     return LHS == RHS;
   }
 };
 
 /// The pointer inside of an identifier comes from a StringMap, so its alignment
 /// is always at least 4 and probably 8 (on 64-bit machines).  Allow LLVM to
 /// steal the low bits.
-template <> struct PointerLikeTypeTraits<mlir::OperationName> {
+template <>
+struct PointerLikeTypeTraits<mlir::OperationName> {
 public:
   static inline void *getAsVoidPointer(mlir::OperationName I) {
     return const_cast<void *>(I.getAsOpaquePointer());
   }
   static inline mlir::OperationName getFromVoidPointer(void *P) {
     return mlir::OperationName::getFromOpaquePointer(P);
   }
   static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<
       mlir::OperationName::RepresentationUnion>::NumLowBitsAvailable;
 };
 
 } // end namespace llvm
 
 #endif

mlir/include/mlir/IR/PatternMatch.h

 /// be tracking various state that would be invalidated when a mutation takes
 /// place.
 class PatternRewriter : public RewriterBase {
 public:
   using RewriterBase::RewriterBase;
 };
 
 //===----------------------------------------------------------------------===//
-// OwningRewritePatternList
+// RewritePatternSet
 //===----------------------------------------------------------------------===//
 
-class OwningRewritePatternList {
+class RewritePatternSet {
   using NativePatternListT = std::vector<std::unique_ptr<RewritePattern>>;
 
 public:
-  OwningRewritePatternList(MLIRContext *context) : context(context) {}
+  RewritePatternSet(MLIRContext *context) : context(context) {}
 
-  /// Construct a OwningRewritePatternList populated with the given pattern.
-  OwningRewritePatternList(MLIRContext *context,
-                           std::unique_ptr<RewritePattern> pattern)
+  /// Construct a RewritePatternSet populated with the given pattern.
+  RewritePatternSet(MLIRContext *context,
       : context(context) {
     nativePatterns.emplace_back(std::move(pattern));
   }
-  OwningRewritePatternList(PDLPatternModule &&pattern)
+  RewritePatternSet(PDLPatternModule &&pattern)
       : context(pattern.getModule()->getContext()),
         pdlPatterns(std::move(pattern)) {}
 
   MLIRContext *getContext() const { return context; }
 
   /// Return the native patterns held in this list.
   NativePatternListT &getNativePatterns() { return nativePatterns; }
 
   /// Return the PDL patterns held in this list.
   PDLPatternModule &getPDLPatterns() { return pdlPatterns; }
 
   /// Clear out all of the held patterns in this list.
   void clear() {
     nativePatterns.clear();
     pdlPatterns.clear();
   }
 
   //===--------------------------------------------------------------------===//
   // Pattern Insertion
   //===--------------------------------------------------------------------===//
 
+  // NOTE: These should be deprecated in favor of the 'add' methods above.
+
+  /// Add an instance of each of the pattern types 'Ts' to the pattern list with
+  /// the given arguments. Return a reference to `this` for chaining insertions.
+  /// Note: ConstructorArg is necessary here to separate the two variadic lists.
+  template <typename... Ts, typename ConstructorArg,
+            typename... ConstructorArgs,
+            typename = std::enable_if_t<sizeof...(Ts) != 0>>
+  RewritePatternSet &add(ConstructorArg &&arg, ConstructorArgs &&... args) {
+    // The following expands a call to emplace_back for each of the pattern
+    // types 'Ts'. This magic is necessary due to a limitation in the places
+    // that a parameter pack can be expanded in c++11.
+    // FIXME: In c++17 this can be simplified by using 'fold expressions'.
+    (void)std::initializer_list<int>{0, (addImpl<Ts>(arg, args...), 0)...};
+    return *this;
+  }
+
+  /// Add an instance of each of the pattern types 'Ts'. Return a reference to
+  /// `this` for chaining insertions.
+  template <typename... Ts>
+  RewritePatternSet &add() {
+    (void)std::initializer_list<int>{0, (addImpl<Ts>(), 0)...};
+    return *this;
+  }
+
+  /// Add the given native pattern to the pattern list. Return a reference to
+  /// `this` for chaining insertions.
+  RewritePatternSet &add(std::unique_ptr<RewritePattern> pattern) {
+    nativePatterns.emplace_back(std::move(pattern));
+    return *this;
+  }
+
+  /// Add the given PDL pattern to the pattern list. Return a reference to
+  /// `this` for chaining insertions.
+  RewritePatternSet &add(PDLPatternModule &&pattern) {
+    pdlPatterns.mergeIn(std::move(pattern));
+    return *this;
+  }
+
+  // Add a matchAndRewrite style pattern represented as a C function pointer.
+  template <typename OpType>
+  RewritePatternSet &add(LogicalResult (*implFn)(OpType,
+                                                 PatternRewriter &rewriter)) {
+    struct FnPattern final : public OpRewritePattern<OpType> {
+      FnPattern(LogicalResult (*implFn)(OpType, PatternRewriter &rewriter),
+                MLIRContext *context)
+          : OpRewritePattern<OpType>(context), implFn(implFn) {}
+
+      LogicalResult matchAndRewrite(OpType op,
+                                    PatternRewriter &rewriter) const override {
+        return implFn(op, rewriter);
+      }
+
+    private:
+      LogicalResult (*implFn)(OpType, PatternRewriter &rewriter);
+    };
+    add(std::make_unique<FnPattern>(std::move(implFn), getContext()));
+    return *this;
+  }
+
+  //===--------------------------------------------------------------------===//
+  // Pattern Insertion
+  //===--------------------------------------------------------------------===//
+
+  // NOTE: These should be deprecated in favor of the 'add' methods above.
+
   /// Add an instance of each of the pattern types 'Ts' to the pattern list with
   /// the given arguments. Return a reference to `this` for chaining insertions.
   /// Note: ConstructorArg is necessary here to separate the two variadic lists.
   template <typename... Ts, typename ConstructorArg,
             typename... ConstructorArgs,
             typename = std::enable_if_t<sizeof...(Ts) != 0>>
-  OwningRewritePatternList &insert(ConstructorArg &&arg,
-                                   ConstructorArgs &&... args) {
+  RewritePatternSet &insert(ConstructorArg &&arg, ConstructorArgs &&... args) {
     // The following expands a call to emplace_back for each of the pattern
     // types 'Ts'. This magic is necessary due to a limitation in the places
     // that a parameter pack can be expanded in c++11.
     // FIXME: In c++17 this can be simplified by using 'fold expressions'.
-    (void)std::initializer_list<int>{0, (insertImpl<Ts>(arg, args...), 0)...};
+    (void)std::initializer_list<int>{0, (addImpl<Ts>(arg, args...), 0)...};
     return *this;
   }
 
   /// Add an instance of each of the pattern types 'Ts'. Return a reference to
   /// `this` for chaining insertions.
   template <typename... Ts>
-  OwningRewritePatternList &insert() {
-    (void)std::initializer_list<int>{0, (insertImpl<Ts>(), 0)...};
+  RewritePatternSet &insert() {
+    (void)std::initializer_list<int>{0, (addImpl<Ts>(), 0)...};
     return *this;
   }
 
   /// Add the given native pattern to the pattern list. Return a reference to
   /// `this` for chaining insertions.
-  OwningRewritePatternList &insert(std::unique_ptr<RewritePattern> pattern) {
+  RewritePatternSet &insert(std::unique_ptr<RewritePattern> pattern) {
     nativePatterns.emplace_back(std::move(pattern));
     return *this;
   }
 
   /// Add the given PDL pattern to the pattern list. Return a reference to
   /// `this` for chaining insertions.
-  OwningRewritePatternList &insert(PDLPatternModule &&pattern) {
+  RewritePatternSet &insert(PDLPatternModule &&pattern) {
     pdlPatterns.mergeIn(std::move(pattern));
     return *this;
   }
 
   // Add a matchAndRewrite style pattern represented as a C function pointer.
   template <typename OpType>
-  OwningRewritePatternList &
+  RewritePatternSet &
   insert(LogicalResult (*implFn)(OpType, PatternRewriter &rewriter)) {
     struct FnPattern final : public OpRewritePattern<OpType> {
       FnPattern(LogicalResult (*implFn)(OpType, PatternRewriter &rewriter),
                 MLIRContext *context)
           : OpRewritePattern<OpType>(context), implFn(implFn) {}
 
       LogicalResult matchAndRewrite(OpType op,
                                     PatternRewriter &rewriter) const override {
         return implFn(op, rewriter);
       }
 
     private:
       LogicalResult (*implFn)(OpType, PatternRewriter &rewriter);
     };
     insert(std::make_unique<FnPattern>(std::move(implFn), getContext()));
     return *this;
   }
 
 private:
   /// Add an instance of the pattern type 'T'. Return a reference to `this` for
   /// chaining insertions.
   template <typename T, typename... Args>
   std::enable_if_t<std::is_base_of<RewritePattern, T>::value>
-  insertImpl(Args &&... args) {
+  addImpl(Args &&... args) {
     nativePatterns.emplace_back(
         std::make_unique<T>(std::forward<Args>(args)...));
   }
   template <typename T, typename... Args>
   std::enable_if_t<std::is_base_of<PDLPatternModule, T>::value>
-  insertImpl(Args &&... args) {
+  addImpl(Args &&... args) {
     pdlPatterns.mergeIn(T(std::forward<Args>(args)...));
   }
 
   MLIRContext *const context;
   NativePatternListT nativePatterns;
   PDLPatternModule pdlPatterns;
 };
 
+using OwningRewritePatternList = RewritePatternSet;
+
 } // end namespace mlir
 
 #endif // MLIR_PATTERN_MATCH_H

mlir/lib/Dialect/Math/Transforms/ExpandTanh.cpp

static LogicalResult convertTanhOp(math::TanhOp op, PatternRewriter &rewriter) {
   auto floatZero = rewriter.getFloatAttr(floatType, 0.0);
   Value zero = rewriter.create<ConstantOp>(loc, floatZero);
   Value cmpRes =
       rewriter.create<CmpFOp>(loc, CmpFPredicate::OGE, op.operand(), zero);
   rewriter.replaceOpWithNewOp<SelectOp>(op, cmpRes, positiveRes, negativeRes);
   return success();
 }
 
-void mlir::populateExpandTanhPattern(OwningRewritePatternList &patterns) {
-  patterns.insert(convertTanhOp);
+void mlir::populateExpandTanhPattern(RewritePatternSet &patterns) {
+  patterns.add(convertTanhOp);
 }