[mlir][Pattern] Refactor the Pattern class into a "metadata only" class

[rriddle]

Summary

The Pattern class was originally intended to be used for solely matching operations, but that use never materialized. All of the pattern infrastructure uses RewritePattern, and the infrastructure for pure matching(Matchers.h) is implemented inline. This means that this class isn't a useful abstraction at the moment, so this revision refactors it to solely encapsulate the "metadata" of a pattern. The metadata includes the various state describing a pattern; benefit, root operation, etc. The API on PatternApplicator is updated to now operate on Patterns as nothing special from RewritePattern is necessary.

This refactoring is also necessary for the upcoming use of PDL patterns alongside C++ rewrite patterns.

Depends On D84580

[ftynse]

Sorry for the delay.

[rriddle]

Rebase

[rriddle]

Rebase

mlir/docs/PatternRewriter.md

 mutation directly.
 
 *   Pattern Application and Cost Model
 
 Each driver is responsible for defining its own operation visitation order as
 well as pattern cost model, but the final application is performed via a
 `PatternApplicator` class. This class takes as input the
 `OwningRewritePatternList` and transforms the patterns based upon a provided
-cost model. This cost model computes a final benefit for a given rewrite
-pattern, using whatever driver specific information necessary. After a cost
-model has been computed, the driver may begin to match patterns against
-operations using `PatternApplicator::matchAndRewrite`.
+cost model. This cost model computes a final benefit for a given pattern, using
+whatever driver specific information necessary. After a cost model has been
+computed, the driver may begin to match patterns against operations using
+`PatternApplicator::matchAndRewrite`.
 
 An example is shown below:
 
 ```c++
 class MyPattern : public RewritePattern {
 public:
   MyPattern(PatternBenefit benefit, MLIRContext *context)
       : RewritePattern(MyOp::getOperationName(), benefit, context) {}

 /// Apply the custom driver to `op`.
 void applyMyPatternDriver(Operation *op,
                           const OwningRewritePatternList &patterns) {
   // Initialize the custom PatternRewriter.
   MyPatternRewriter rewriter(op->getContext());
 
   // Create the applicator and apply our cost model.
   PatternApplicator applicator(patterns);
-  applicator.applyCostModel([](const RewritePattern &pattern) {
+  applicator.applyCostModel([](const Pattern &pattern) {
     // Apply a default cost model.
     // Note: This is just for demonstration, if the default cost model is truly
     //       desired `applicator.applyDefaultCostModel()` should be used
     //       instead.
     return pattern.getBenefit();
   });
 
   // Try to match and apply a pattern.

mlir/include/mlir/IR/PatternMatch.h

public:
   bool operator<=(const PatternBenefit &rhs) const { return !(*this > rhs); }
   bool operator>=(const PatternBenefit &rhs) const { return !(*this < rhs); }
 
 private:
   unsigned short representation;
 };
 
 //===----------------------------------------------------------------------===//
-// Pattern class
+// Pattern
 //===----------------------------------------------------------------------===//
 
-/// Instances of Pattern can be matched against SSA IR.  These matches get used
-/// in ways dependent on their subclasses and the driver doing the matching.
-/// For example, RewritePatterns implement a rewrite from one matched pattern
-/// to a replacement DAG tile.
+/// This class contains all of the data related to a pattern, but does not
+/// contain any methods or logic for the actual matching. This class is solely
+/// used to interface with the metadata of a pattern, such as the benefit or
+/// root operation.
 class Pattern {
 public:
+  /// Return a list of operations that may be generated when rewriting an
+  /// operation instance with this pattern.
+  ArrayRef<OperationName> getGeneratedOps() const { return generatedOps; }
+
+  /// Return the root node that this pattern matches. Patterns that can match
+  /// multiple root types return None.
+  Optional<OperationName> getRootKind() const { return rootKind; }
+
   /// Return the benefit (the inverse of "cost") of matching this pattern.  The
   /// benefit of a Pattern is always static - rewrites that may have dynamic
   /// benefit can be instantiated multiple times (different Pattern instances)
   /// for each benefit that they may return, and be guarded by different match
   /// condition predicates.
   PatternBenefit getBenefit() const { return benefit; }
 
-  /// Return the root node that this pattern matches. Patterns that can match
-  /// multiple root types return None.
-  Optional<OperationName> getRootKind() const { return rootKind; }
-
-  //===--------------------------------------------------------------------===//
-  // Implementation hooks for patterns to implement.
-  //===--------------------------------------------------------------------===//
-
-  /// Attempt to match against code rooted at the specified operation,
-  /// which is the same operation code as getRootKind().
-  virtual LogicalResult match(Operation *op) const = 0;
-
-  virtual ~Pattern() {}
+  /// Returns true if this pattern is known to result in recursive application,
+  /// i.e. this pattern may generate IR that also matches this pattern, but is
+  /// known to bound the recursion. This signals to a rewrite driver that it is
+  /// safe to apply this pattern recursively to generated IR.
+  bool hasBoundedRewriteRecursion() const { return hasBoundedRecursion; }
 
 protected:
   /// This class acts as a special tag that makes the desire to match "any"
   /// operation type explicit. This helps to avoid unnecessary usages of this
   /// feature, and ensures that the user is making a conscious decision.
   struct MatchAnyOpTypeTag {};
 
-  /// This constructor is used for patterns that match against a specific
-  /// operation type. The `benefit` is the expected benefit of matching this
-  /// pattern.
+  /// Construct a pattern with a certain benefit that matches the operation
+  /// with the given root name.
   Pattern(StringRef rootName, PatternBenefit benefit, MLIRContext *context);
+  /// Construct a pattern with a certain benefit that matches any operation
+  /// type. `MatchAnyOpTypeTag` is just a tag to ensure that the "match any"
+  /// behavior is what the user actually desired, `MatchAnyOpTypeTag()` should
+  /// always be supplied here.
+  Pattern(PatternBenefit benefit, MatchAnyOpTypeTag tag);
+  /// Construct a pattern with a certain benefit that matches the operation with
+  /// the given root name. `generatedNames` contains the names of operations
+  /// that may be generated during a successful rewrite.
+  Pattern(StringRef rootName, ArrayRef<StringRef> generatedNames,
+          PatternBenefit benefit, MLIRContext *context);
+  /// Construct a pattern that may match any operation type. `generatedNames`
+  /// contains the names of operations that may be generated during a successful
+  /// rewrite. `MatchAnyOpTypeTag` is just a tag to ensure that the "match any"
+  /// behavior is what the user actually desired, `MatchAnyOpTypeTag()` should
+  /// always be supplied here.
+  Pattern(ArrayRef<StringRef> generatedNames, PatternBenefit benefit,
+          MLIRContext *context, MatchAnyOpTypeTag tag);
 
-  /// This constructor is used when a pattern may match against multiple
-  /// different types of operations. The `benefit` is the expected benefit of
-  /// matching this pattern. `MatchAnyOpTypeTag` is just a tag to ensure that
-  /// the "match any" behavior is what the user actually desired,
-  /// `MatchAnyOpTypeTag()` should always be supplied here.
-  Pattern(PatternBenefit benefit, MatchAnyOpTypeTag);
+  /// Set the flag detailing if this pattern has bounded rewrite recursion or
+  /// not.
+  void setHasBoundedRewriteRecursion(bool hasBoundedRecursionArg = true) {
+    hasBoundedRecursion = hasBoundedRecursionArg;
+  }
 
 private:
+  /// A list of the potential operations that may be generated when rewriting
+  /// an op with this pattern.
+  SmallVector<OperationName, 2> generatedOps;
+
   /// The root operation of the pattern. If the pattern matches a specific
   /// operation, this contains the name of that operation. Contains None
   /// otherwise.
   Optional<OperationName> rootKind;
 
   /// The expected benefit of matching this pattern.
   const PatternBenefit benefit;
 
-  virtual void anchor();
+  /// A boolean flag of whether this pattern has bounded recursion or not.
+  bool hasBoundedRecursion = false;
 };
 
+//===----------------------------------------------------------------------===//
+// RewritePattern
+//===----------------------------------------------------------------------===//
+
 /// RewritePattern is the common base class for all DAG to DAG replacements.
 /// There are two possible usages of this class:
 ///   * Multi-step RewritePattern with "match" and "rewrite"
 ///     - By overloading the "match" and "rewrite" functions, the user can
 ///       separate the concerns of matching and rewriting.
 ///   * Single-step RewritePattern with "matchAndRewrite"
 ///     - By overloading the "matchAndRewrite" function, the user can perform
 ///       the rewrite in the same call as the match.
 ///
 class RewritePattern : public Pattern {
 public:
+  virtual ~RewritePattern() {}
+
   /// Rewrite the IR rooted at the specified operation with the result of
   /// this pattern, generating any new operations with the specified
   /// builder.  If an unexpected error is encountered (an internal
   /// compiler error), it is emitted through the normal MLIR diagnostic
   /// hooks and the IR is left in a valid state.
   virtual void rewrite(Operation *op, PatternRewriter &rewriter) const;
 
   /// Attempt to match against code rooted at the specified operation,
   /// which is the same operation code as getRootKind().
-  LogicalResult match(Operation *op) const override;
+  virtual LogicalResult match(Operation *op) const;
 
   /// Attempt to match against code rooted at the specified operation,
   /// which is the same operation code as getRootKind(). If successful, this
   /// function will automatically perform the rewrite.
   virtual LogicalResult matchAndRewrite(Operation *op,
                                         PatternRewriter &rewriter) const {
     if (succeeded(match(op))) {
       rewrite(op, rewriter);
       return success();
     }
     return failure();
   }
 
-  /// Returns true if this pattern is known to result in recursive application,
-  /// i.e. this pattern may generate IR that also matches this pattern, but is
-  /// known to bound the recursion. This signals to a rewriter that it is safe
-  /// to apply this pattern recursively to generated IR.
-  virtual bool hasBoundedRewriteRecursion() const { return false; }
-
-  /// Return a list of operations that may be generated when rewriting an
-  /// operation instance with this pattern.
-  ArrayRef<OperationName> getGeneratedOps() const { return generatedOps; }
-
 protected:
-  /// Construct a rewrite pattern with a certain benefit that matches the
-  /// operation with the given root name.
-  RewritePattern(StringRef rootName, PatternBenefit benefit,
-                 MLIRContext *context)
-      : Pattern(rootName, benefit, context) {}
-  /// Construct a rewrite pattern with a certain benefit that matches any
-  /// operation type. `MatchAnyOpTypeTag` is just a tag to ensure that the
-  /// "match any" behavior is what the user actually desired,
-  /// `MatchAnyOpTypeTag()` should always be supplied here.
-  RewritePattern(PatternBenefit benefit, MatchAnyOpTypeTag tag)
-      : Pattern(benefit, tag) {}
-  /// Construct a rewrite pattern with a certain benefit that matches the
-  /// operation with the given root name. `generatedNames` contains the names of
-  /// operations that may be generated during a successful rewrite.
-  RewritePattern(StringRef rootName, ArrayRef<StringRef> generatedNames,
-                 PatternBenefit benefit, MLIRContext *context);
-  /// Construct a rewrite pattern that may match any operation type.
-  /// `generatedNames` contains the names of operations that may be generated
-  /// during a successful rewrite. `MatchAnyOpTypeTag` is just a tag to ensure
-  /// that the "match any" behavior is what the user actually desired,
-  /// `MatchAnyOpTypeTag()` should always be supplied here.
-  RewritePattern(ArrayRef<StringRef> generatedNames, PatternBenefit benefit,
-                 MLIRContext *context, MatchAnyOpTypeTag tag);
+  /// Inherit the base constructors from `Pattern`.
+  using Pattern::Pattern;
 
-  /// A list of the potential operations that may be generated when rewriting
-  /// an op with this pattern.
-  SmallVector<OperationName, 2> generatedOps;
+  /// An anchor for the virtual table.
+  virtual void anchor();
 };
 
 /// OpRewritePattern is a wrapper around RewritePattern that allows for
 /// matching and rewriting against an instance of a derived operation class as
 /// opposed to a raw Operation.
 template <typename SourceOp> struct OpRewritePattern : public RewritePattern {
   /// Patterns must specify the root operation name they match against, and can
   /// also specify the benefit of the pattern matching.
if (succeeded(match(op))) {
       rewrite(op, rewriter);
       return success();
     }
     return failure();
   }
 };
 
 //===----------------------------------------------------------------------===//
-// PatternRewriter class
+// PatternRewriter
 //===----------------------------------------------------------------------===//
 
 /// This class coordinates the application of a pattern to the current function,
 /// providing a way to create operations and keep track of what gets deleted.
 ///
 /// These class serves two purposes:
 ///  1) it is the interface that patterns interact with to make mutations to the
 ///     IR they are being applied to.

 /// This class manages the application of a group of rewrite patterns, with a
 /// user-provided cost model.
 class PatternApplicator {
 public:
   /// The cost model dynamically assigns a PatternBenefit to a particular
   /// pattern. Users can query contained patterns and pass analysis results to
   /// applyCostModel. Patterns to be discarded should have a benefit of
   /// `impossibleToMatch`.
-  using CostModel = function_ref<PatternBenefit(const RewritePattern &)>;
+  using CostModel = function_ref<PatternBenefit(const Pattern &)>;
 
   explicit PatternApplicator(const OwningRewritePatternList &owningPatternList)
       : owningPatternList(owningPatternList) {}
 
   /// Attempt to match and rewrite the given op with any pattern, allowing a
   /// predicate to decide if a pattern can be applied or not, and hooks for if
   /// the pattern match was a success or failure.
   ///
   /// canApply:  called before each match and rewrite attempt; return false to
   ///            skip pattern.
   /// onFailure: called when a pattern fails to match to perform cleanup.
   /// onSuccess: called when a pattern match succeeds; return failure() to
   ///            invalidate the match and try another pattern.
-  LogicalResult matchAndRewrite(
-      Operation *op, PatternRewriter &rewriter,
-      function_ref<bool(const RewritePattern &)> canApply = {},
-      function_ref<void(const RewritePattern &)> onFailure = {},
-      function_ref<LogicalResult(const RewritePattern &)> onSuccess = {});
+  LogicalResult
+  matchAndRewrite(Operation *op, PatternRewriter &rewriter,
+                  function_ref<bool(const Pattern &)> canApply = {},
+                  function_ref<void(const Pattern &)> onFailure = {},
+                  function_ref<LogicalResult(const Pattern &)> onSuccess = {});
 
   /// Apply a cost model to the patterns within this applicator.
   void applyCostModel(CostModel model);
 
   /// Apply the default cost model that solely uses the pattern's static
   /// benefit.
   void applyDefaultCostModel() {
-    applyCostModel(
-        [](const RewritePattern &pattern) { return pattern.getBenefit(); });
+    applyCostModel([](const Pattern &pattern) { return pattern.getBenefit(); });
   }
 
-  /// Walk all of the rewrite patterns within the applicator.
-  void walkAllPatterns(function_ref<void(const RewritePattern &)> walk);
+  /// Walk all of the patterns within the applicator.
+  void walkAllPatterns(function_ref<void(const Pattern &)> walk);
 
 private:
   /// Attempt to match and rewrite the given op with the given pattern, allowing
   /// a predicate to decide if a pattern can be applied or not, and hooks for if
   /// the pattern match was a success or failure.
-  LogicalResult matchAndRewrite(
-      Operation *op, const RewritePattern &pattern, PatternRewriter &rewriter,
-      function_ref<bool(const RewritePattern &)> canApply,
-      function_ref<void(const RewritePattern &)> onFailure,
-      function_ref<LogicalResult(const RewritePattern &)> onSuccess);
+  LogicalResult
+  matchAndRewrite(Operation *op, const RewritePattern &pattern,
+                  PatternRewriter &rewriter,
+                  function_ref<bool(const Pattern &)> canApply,
+                  function_ref<void(const Pattern &)> onFailure,
+                  function_ref<LogicalResult(const Pattern &)> onSuccess);
 
   /// The list that owns the patterns used within this applicator.
   const OwningRewritePatternList &owningPatternList;
 
   /// The set of patterns to match for each operation, stable sorted by benefit.
   DenseMap<OperationName, SmallVector<RewritePattern *, 2>> patterns;
   /// The set of patterns that may match against any operation type, stable
   /// sorted by benefit.

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

 //   destination subvector
 //   3. the destination subvector is inserted back in the proper place
 //   4. the op is replaced by the result of step 3.
 // The new InsertStridedSlice from step 2. will be picked up by a
 // `VectorInsertStridedSliceOpSameRankRewritePattern`.
 class VectorInsertStridedSliceOpSameRankRewritePattern
     : public OpRewritePattern<InsertStridedSliceOp> {
 public:
-  using OpRewritePattern<InsertStridedSliceOp>::OpRewritePattern;
+  VectorInsertStridedSliceOpSameRankRewritePattern(MLIRContext *ctx)
+      : OpRewritePattern<InsertStridedSliceOp>(ctx) {
+    // This pattern creates recursive InsertStridedSliceOp, but the recursion is
+    // bounded as the rank is strictly decreasing.
+    setHasBoundedRewriteRecursion();
+  }
 
   LogicalResult matchAndRewrite(InsertStridedSliceOp op,
                                 PatternRewriter &rewriter) const override {
     auto srcType = op.getSourceVectorType();
     auto dstType = op.getDestVectorType();
 
     if (op.offsets().getValue().empty())
       return failure();
for (int64_t off = offset, e = offset + size * stride, idx = 0; off < e;
       }
       // 4. Insert the extractedSource into the res vector.
       res = insertOne(rewriter, loc, extractedSource, res, off);
     }
 
     rewriter.replaceOp(op, res);
     return success();
   }
-  /// This pattern creates recursive InsertStridedSliceOp, but the recursion is
-  /// bounded as the rank is strictly decreasing.
-  bool hasBoundedRewriteRecursion() const final { return true; }
 };
 
 /// Returns the strides if the memory underlying `memRefType` has a contiguous
 /// static layout.
 static llvm::Optional<SmallVector<int64_t, 4>>
 computeContiguousStrides(MemRefType memRefType) {
   int64_t offset;
   SmallVector<int64_t, 4> strides;

 };
 
 /// Progressive lowering of ExtractStridedSliceOp to either:
 ///   1. express single offset extract as a direct shuffle.
 ///   2. extract + lower rank strided_slice + insert for the n-D case.
 class VectorExtractStridedSliceOpConversion
     : public OpRewritePattern<ExtractStridedSliceOp> {
 public:
-  using OpRewritePattern<ExtractStridedSliceOp>::OpRewritePattern;
+  VectorExtractStridedSliceOpConversion(MLIRContext *ctx)
+      : OpRewritePattern<ExtractStridedSliceOp>(ctx) {
+    // This pattern creates recursive ExtractStridedSliceOp, but the recursion
+    // is bounded as the rank is strictly decreasing.
+    setHasBoundedRewriteRecursion();
+  }
 
   LogicalResult matchAndRewrite(ExtractStridedSliceOp op,
                                 PatternRewriter &rewriter) const override {
     auto dstType = op.getResult().getType().cast<VectorType>();
 
     assert(!op.offsets().getValue().empty() && "Unexpected empty offsets");
 
     int64_t offset =
for (int64_t off = offset, e = offset + size * stride, idx = 0; off < e;
           loc, one, getI64SubArray(op.offsets(), /* dropFront=*/1),
           getI64SubArray(op.sizes(), /* dropFront=*/1),
           getI64SubArray(op.strides(), /* dropFront=*/1));
       res = insertOne(rewriter, loc, extracted, res, idx);
     }
     rewriter.replaceOp(op, res);
     return success();
   }
-  /// This pattern creates recursive ExtractStridedSliceOp, but the recursion is
-  /// bounded as the rank is strictly decreasing.
-  bool hasBoundedRewriteRecursion() const final { return true; }
 };
 
 } // namespace
 
 /// Populate the given list with patterns that convert from Vector to LLVM.
 void mlir::populateVectorToLLVMConversionPatterns(
     LLVMTypeConverter &converter, OwningRewritePatternList &patterns,
     bool reassociateFPReductions, bool enableIndexOptimizations) {

mlir/lib/IR/PatternMatch.cpp

 #include "mlir/IR/Operation.h"
 #include "mlir/IR/Value.h"
 #include "llvm/Support/Debug.h"
 
 using namespace mlir;
 
 #define DEBUG_TYPE "pattern-match"
 
+//===----------------------------------------------------------------------===//
+// PatternBenefit
+//===----------------------------------------------------------------------===//
+
 PatternBenefit::PatternBenefit(unsigned benefit) : representation(benefit) {
   assert(representation == benefit && benefit != ImpossibleToMatchSentinel &&
          "This pattern match benefit is too large to represent");
 }
 
 unsigned short PatternBenefit::getBenefit() const {
   assert(!isImpossibleToMatch() && "Pattern doesn't match");
   return representation;
 }
 
 //===----------------------------------------------------------------------===//
-// Pattern implementation
+// Pattern
 //===----------------------------------------------------------------------===//
 
 Pattern::Pattern(StringRef rootName, PatternBenefit benefit,
                  MLIRContext *context)
     : rootKind(OperationName(rootName, context)), benefit(benefit) {}
-Pattern::Pattern(PatternBenefit benefit, MatchAnyOpTypeTag)
+Pattern::Pattern(PatternBenefit benefit, MatchAnyOpTypeTag tag)
     : benefit(benefit) {}
-
-// Out-of-line vtable anchor.
-void Pattern::anchor() {}
-
-//===----------------------------------------------------------------------===//
-// RewritePattern and PatternRewriter implementation
-//===----------------------------------------------------------------------===//
-
-void RewritePattern::rewrite(Operation *op, PatternRewriter &rewriter) const {
-  llvm_unreachable("need to implement either matchAndRewrite or one of the "
-                   "rewrite functions!");
-}
-
-LogicalResult RewritePattern::match(Operation *op) const {
-  llvm_unreachable("need to implement either match or matchAndRewrite!");
-}
-
-RewritePattern::RewritePattern(StringRef rootName,
-                               ArrayRef<StringRef> generatedNames,
-                               PatternBenefit benefit, MLIRContext *context)
+Pattern::Pattern(StringRef rootName, ArrayRef<StringRef> generatedNames,
     : Pattern(rootName, benefit, context) {
   generatedOps.reserve(generatedNames.size());
   std::transform(generatedNames.begin(), generatedNames.end(),
                  std::back_inserter(generatedOps), [context](StringRef name) {
                    return OperationName(name, context);
                  });
 }
-RewritePattern::RewritePattern(ArrayRef<StringRef> generatedNames,
-                               PatternBenefit benefit, MLIRContext *context,
-                               MatchAnyOpTypeTag tag)
+Pattern::Pattern(ArrayRef<StringRef> generatedNames, PatternBenefit benefit,
+                 MLIRContext *context, MatchAnyOpTypeTag tag)
     : Pattern(benefit, tag) {
   generatedOps.reserve(generatedNames.size());
   std::transform(generatedNames.begin(), generatedNames.end(),
                  std::back_inserter(generatedOps), [context](StringRef name) {
                    return OperationName(name, context);
                  });
 }
 
+//===----------------------------------------------------------------------===//
+// RewritePattern
+//===----------------------------------------------------------------------===//
+
+void RewritePattern::rewrite(Operation *op, PatternRewriter &rewriter) const {
+  llvm_unreachable("need to implement either matchAndRewrite or one of the "
+                   "rewrite functions!");
+}
+
+LogicalResult RewritePattern::match(Operation *op) const {
+  llvm_unreachable("need to implement either match or matchAndRewrite!");
+}
+
+/// Out-of-line vtable anchor.
+void RewritePattern::anchor() {}
+
+//===----------------------------------------------------------------------===//
+// PatternRewriter
+//===----------------------------------------------------------------------===//
+
 PatternRewriter::~PatternRewriter() {
   // Out of line to provide a vtable anchor for the class.
 }
 
 /// This method performs the final replacement for a pattern, where the
 /// results of the operation are updated to use the specified list of SSA
 /// values.
 void PatternRewriter::replaceOp(Operation *op, ValueRange newValues) {
void PatternRewriter::cloneRegionBefore(Region &region, Region &parent,
   BlockAndValueMapping mapping;
   cloneRegionBefore(region, parent, before, mapping);
 }
 void PatternRewriter::cloneRegionBefore(Region &region, Block *before) {
   cloneRegionBefore(region, *before->getParent(), before->getIterator());
 }
 
 //===----------------------------------------------------------------------===//
-// PatternMatcher implementation
+// PatternApplicator
 //===----------------------------------------------------------------------===//
 
 void PatternApplicator::applyCostModel(CostModel model) {
   // Separate patterns by root kind to simplify lookup later on.
   patterns.clear();
   anyOpPatterns.clear();
   for (const auto &pat : owningPatternList) {
     // If the pattern is always impossible to match, just ignore it.
auto processPatternList = [&](SmallVectorImpl<RewritePattern *> &list) {
     }
   };
   for (auto &it : patterns)
     processPatternList(it.second);
   processPatternList(anyOpPatterns);
 }
 
 void PatternApplicator::walkAllPatterns(
-    function_ref<void(const RewritePattern &)> walk) {
+    function_ref<void(const Pattern &)> walk) {
   for (auto &it : owningPatternList)
     walk(*it);
 }
 
 LogicalResult PatternApplicator::matchAndRewrite(
     Operation *op, PatternRewriter &rewriter,
-    function_ref<bool(const RewritePattern &)> canApply,
-    function_ref<void(const RewritePattern &)> onFailure,
-    function_ref<LogicalResult(const RewritePattern &)> onSuccess) {
+    function_ref<bool(const Pattern &)> canApply,
+    function_ref<void(const Pattern &)> onFailure,
+    function_ref<LogicalResult(const Pattern &)> onSuccess) {
   // Check to see if there are patterns matching this specific operation type.
   MutableArrayRef<RewritePattern *> opPatterns;
   auto patternIt = patterns.find(op->getName());
   if (patternIt != patterns.end())
     opPatterns = patternIt->second;
 
   // Process the patterns for that match the specific operation type, and any
   // operation type in an interleaved fashion.
if (succeeded(matchAndRewrite(op, *pattern, rewriter, canApply, onFailure,
                                   onSuccess)))
       return success();
   }
   return failure();
 }
 
 LogicalResult PatternApplicator::matchAndRewrite(
     Operation *op, const RewritePattern &pattern, PatternRewriter &rewriter,
-    function_ref<bool(const RewritePattern &)> canApply,
-    function_ref<void(const RewritePattern &)> onFailure,
-    function_ref<LogicalResult(const RewritePattern &)> onSuccess) {
+    function_ref<bool(const Pattern &)> canApply,
+    function_ref<void(const Pattern &)> onFailure,
+    function_ref<LogicalResult(const Pattern &)> onSuccess) {
   // Check that the pattern can be applied.
   if (canApply && !canApply(pattern))
     return failure();
 
   // Try to match and rewrite this pattern. The patterns are sorted by
   // benefit, so if we match we can immediately rewrite.
   rewriter.setInsertionPoint(op);
   if (succeeded(pattern.matchAndRewrite(op, rewriter)))
     return success(!onSuccess || succeeded(onSuccess(pattern)));
 
   if (onFailure)
     onFailure(pattern);
   return failure();
 }

mlir/lib/Transforms/DialectConversion.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // OperationLegalizer
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// A set of rewrite patterns that can be used to legalize a given operation.
-using LegalizationPatterns = SmallVector<const RewritePattern *, 1>;
+using LegalizationPatterns = SmallVector<const Pattern *, 1>;
 
 /// This class defines a recursive operation legalizer.
 class OperationLegalizer {
 public:
   using LegalizationAction = ConversionTarget::LegalizationAction;
 
   OperationLegalizer(ConversionTarget &targetInfo,
                      const OwningRewritePatternList &patterns);
private:
 
   /// Attempt to legalize the given operation by applying a pattern. Returns
   /// success if the operation was legalized, failure otherwise.
   LogicalResult legalizeWithPattern(Operation *op,
                                     ConversionPatternRewriter &rewriter);
 
   /// Return true if the given pattern may be applied to the given operation,
   /// false otherwise.
-  bool canApplyPattern(Operation *op, const RewritePattern &pattern,
+  bool canApplyPattern(Operation *op, const Pattern &pattern,
                        ConversionPatternRewriter &rewriter);
 
   /// Legalize the resultant IR after successfully applying the given pattern.
-  LogicalResult legalizePatternResult(Operation *op,
-                                      const RewritePattern &pattern,
+  LogicalResult legalizePatternResult(Operation *op, const Pattern &pattern,
                                       ConversionPatternRewriter &rewriter,
                                       RewriterState &curState);
 
   /// Legalizes the actions registered during the execution of a pattern.
   LogicalResult legalizePatternBlockActions(Operation *op,
                                             ConversionPatternRewriter &rewriter,
                                             ConversionPatternRewriterImpl &impl,
                                             RewriterState &state,
private:
   /// the smallest legalization depth of any of the patterns. See
   /// `computeLegalizationGraphBenefit` for the breakdown of the cost model.
   unsigned applyCostModelToPatterns(
       LegalizationPatterns &patterns,
       DenseMap<OperationName, unsigned> &minOpPatternDepth,
       DenseMap<OperationName, LegalizationPatterns> &legalizerPatterns);
 
   /// The current set of patterns that have been applied.
-  SmallPtrSet<const RewritePattern *, 8> appliedPatterns;
+  SmallPtrSet<const Pattern *, 8> appliedPatterns;
 
   /// The legalization information provided by the target.
   ConversionTarget &target;
 
   /// The pattern applicator to use for conversions.
   PatternApplicator applicator;
 };
 } // namespace

 }
 
 LogicalResult
 OperationLegalizer::legalizeWithPattern(Operation *op,
                                         ConversionPatternRewriter &rewriter) {
   auto &rewriterImpl = rewriter.getImpl();
 
   // Functor that returns if the given pattern may be applied.
-  auto canApply = [&](const RewritePattern &pattern) {
+  auto canApply = [&](const Pattern &pattern) {
     return canApplyPattern(op, pattern, rewriter);
   };
 
   // Functor that cleans up the rewriter state after a pattern failed to match.
   RewriterState curState = rewriterImpl.getCurrentState();
-  auto onFailure = [&](const RewritePattern &pattern) {
+  auto onFailure = [&](const Pattern &pattern) {
     LLVM_DEBUG(logFailure(rewriterImpl.logger, "pattern failed to match"));
     rewriterImpl.resetState(curState);
     appliedPatterns.erase(&pattern);
   };
 
   // Functor that performs additional legalization when a pattern is
   // successfully applied.
-  auto onSuccess = [&](const RewritePattern &pattern) {
+  auto onSuccess = [&](const Pattern &pattern) {
     auto result = legalizePatternResult(op, pattern, rewriter, curState);
     appliedPatterns.erase(&pattern);
     if (failed(result))
       rewriterImpl.resetState(curState);
     return result;
   };
 
   // Try to match and rewrite a pattern on this operation.
   return applicator.matchAndRewrite(op, rewriter, canApply, onFailure,
                                     onSuccess);
 }
 
-bool OperationLegalizer::canApplyPattern(Operation *op,
-                                         const RewritePattern &pattern,
+bool OperationLegalizer::canApplyPattern(Operation *op, const Pattern &pattern,
                                          ConversionPatternRewriter &rewriter) {
   LLVM_DEBUG({
     auto &os = rewriter.getImpl().logger;
     os.getOStream() << "\n";
     os.startLine() << "* Pattern : '" << op->getName() << " -> (";
     llvm::interleaveComma(pattern.getGeneratedOps(), llvm::dbgs());
     os.getOStream() << ")' {\n";
     os.indent();
   });
 
   // Ensure that we don't cycle by not allowing the same pattern to be
   // applied twice in the same recursion stack if it is not known to be safe.
   if (!pattern.hasBoundedRewriteRecursion() &&
       !appliedPatterns.insert(&pattern).second) {
     LLVM_DEBUG(
         logFailure(rewriter.getImpl().logger, "pattern was already applied"));
     return false;
   }
   return true;
 }
 
-LogicalResult OperationLegalizer::legalizePatternResult(
-    Operation *op, const RewritePattern &pattern,
-    ConversionPatternRewriter &rewriter, RewriterState &curState) {
+LogicalResult
+OperationLegalizer::legalizePatternResult(Operation *op, const Pattern &pattern,
+                                          ConversionPatternRewriter &rewriter,
+                                          RewriterState &curState) {
   auto &impl = rewriter.getImpl();
 
 #ifndef NDEBUG
   assert(impl.pendingRootUpdates.empty() && "dangling root updates");
 #endif
 
   // Check that the root was either replaced or updated in place.
   auto replacedRoot = [&] {

 
 void OperationLegalizer::buildLegalizationGraph(
     LegalizationPatterns &anyOpLegalizerPatterns,
     DenseMap<OperationName, LegalizationPatterns> &legalizerPatterns) {
   // A mapping between an operation and a set of operations that can be used to
   // generate it.
   DenseMap<OperationName, SmallPtrSet<OperationName, 2>> parentOps;
   // A mapping between an operation and any currently invalid patterns it has.
-  DenseMap<OperationName, SmallPtrSet<const RewritePattern *, 2>>
-      invalidPatterns;
+  DenseMap<OperationName, SmallPtrSet<const Pattern *, 2>> invalidPatterns;
   // A worklist of patterns to consider for legality.
-  llvm::SetVector<const RewritePattern *> patternWorklist;
+  llvm::SetVector<const Pattern *> patternWorklist;
 
   // Build the mapping from operations to the parent ops that may generate them.
-  applicator.walkAllPatterns([&](const RewritePattern &pattern) {
+  applicator.walkAllPatterns([&](const Pattern &pattern) {
     Optional<OperationName> root = pattern.getRootKind();
 
     // If the pattern has no specific root, we can't analyze the relationship
     // between the root op and generated operations. Given that, add all such
     // patterns to the legalization set.
     if (!root) {
       anyOpLegalizerPatterns.push_back(&pattern);
       return;
void OperationLegalizer::buildLegalizationGraph(
   });
 
   // If there are any patterns that don't have a specific root kind, we can't
   // make direct assumptions about what operations will never be legalized.
   // Note: Technically we could, but it would require an analysis that may
   // recurse into itself. It would be better to perform this kind of filtering
   // at a higher level than here anyways.
   if (!anyOpLegalizerPatterns.empty()) {
-    for (const RewritePattern *pattern : patternWorklist)
+    for (const Pattern *pattern : patternWorklist)
       legalizerPatterns[*pattern->getRootKind()].push_back(pattern);
     return;
   }
 
   while (!patternWorklist.empty()) {
     auto *pattern = patternWorklist.pop_back_val();
 
     // Check to see if any of the generated operations are invalid.
void OperationLegalizer::computeLegalizationGraphBenefit(
   // legalization depth.
   if (!anyOpLegalizerPatterns.empty())
     applyCostModelToPatterns(anyOpLegalizerPatterns, minOpPatternDepth,
                              legalizerPatterns);
 
   // Apply a cost model to the pattern applicator. We order patterns first by
   // depth then benefit. `legalizerPatterns` contains per-op patterns by
   // decreasing benefit.
-  applicator.applyCostModel([&](const RewritePattern &p) {
-    ArrayRef<const RewritePattern *> orderedPatternList;
-    if (Optional<OperationName> rootName = p.getRootKind())
+  applicator.applyCostModel([&](const Pattern &pattern) {
+    ArrayRef<const Pattern *> orderedPatternList;
+    if (Optional<OperationName> rootName = pattern.getRootKind())
       orderedPatternList = legalizerPatterns[*rootName];
     else
       orderedPatternList = anyOpLegalizerPatterns;
 
     // If the pattern is not found, then it was removed and cannot be matched.
-    auto it = llvm::find(orderedPatternList, &p);
+    auto it = llvm::find(orderedPatternList, &pattern);
     if (it == orderedPatternList.end())
       return PatternBenefit::impossibleToMatch();
 
     // Patterns found earlier in the list have higher benefit.
     return PatternBenefit(std::distance(it, orderedPatternList.end()));
   });
 }
 

 
 unsigned OperationLegalizer::applyCostModelToPatterns(
     LegalizationPatterns &patterns,
     DenseMap<OperationName, unsigned> &minOpPatternDepth,
     DenseMap<OperationName, LegalizationPatterns> &legalizerPatterns) {
   unsigned minDepth = std::numeric_limits<unsigned>::max();
 
   // Compute the depth for each pattern within the set.
-  SmallVector<std::pair<const RewritePattern *, unsigned>, 4> patternsByDepth;
+  SmallVector<std::pair<const Pattern *, unsigned>, 4> patternsByDepth;
   patternsByDepth.reserve(patterns.size());
-  for (const RewritePattern *pattern : patterns) {
+  for (const Pattern *pattern : patterns) {
     unsigned depth = 0;
     for (auto generatedOp : pattern->getGeneratedOps()) {
       unsigned generatedOpDepth = computeOpLegalizationDepth(
           generatedOp, minOpPatternDepth, legalizerPatterns);
       depth = std::max(depth, generatedOpDepth + 1);
     }
     patternsByDepth.emplace_back(pattern, depth);
 
     // Update the minimum depth of the pattern list.
     minDepth = std::min(minDepth, depth);
   }
 
   // If the operation only has one legalization pattern, there is no need to
   // sort them.
   if (patternsByDepth.size() == 1)
     return minDepth;
 
   // Sort the patterns by those likely to be the most beneficial.
   llvm::array_pod_sort(
       patternsByDepth.begin(), patternsByDepth.end(),
-      [](const std::pair<const RewritePattern *, unsigned> *lhs,
-         const std::pair<const RewritePattern *, unsigned> *rhs) {
+      [](const std::pair<const Pattern *, unsigned> *lhs,
+         const std::pair<const Pattern *, unsigned> *rhs) {
         // First sort by the smaller pattern legalization depth.
         if (lhs->second != rhs->second)
           return llvm::array_pod_sort_comparator<unsigned>(&lhs->second,
                                                            &rhs->second);
 
         // Then sort by the larger pattern benefit.
         auto lhsBenefit = lhs->first->getBenefit();
         auto rhsBenefit = rhs->first->getBenefit();

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

 };
 
 //===----------------------------------------------------------------------===//
 // Recursive Rewrite Testing
 /// This pattern is applied to the same operation multiple times, but has a
 /// bounded recursion.
 struct TestBoundedRecursiveRewrite
     : public OpRewritePattern<TestRecursiveRewriteOp> {
-  using OpRewritePattern<TestRecursiveRewriteOp>::OpRewritePattern;
+  TestBoundedRecursiveRewrite(MLIRContext *ctx)
+      : OpRewritePattern<TestRecursiveRewriteOp>(ctx) {
+    // The conversion target handles bounding the recursion of this pattern.
+    setHasBoundedRewriteRecursion();
+  }
 
   LogicalResult matchAndRewrite(TestRecursiveRewriteOp op,
                                 PatternRewriter &rewriter) const final {
     // Decrement the depth of the op in-place.
     rewriter.updateRootInPlace(op, [&] {
       op.setAttr("depth", rewriter.getI64IntegerAttr(op.depth() - 1));
     });
     return success();
   }
-
-  /// The conversion target handles bounding the recursion of this pattern.
-  bool hasBoundedRewriteRecursion() const final { return true; }
 };
 
 struct TestNestedOpCreationUndoRewrite
     : public OpRewritePattern<IllegalOpWithRegionAnchor> {
   using OpRewritePattern<IllegalOpWithRegionAnchor>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(IllegalOpWithRegionAnchor op,
                                 PatternRewriter &rewriter) const final {