[mlir] Remove the deprecated OpConversionPattern::matchAndRewrite methods

[rriddle]

Summary

These have been deprecated for a few weeks now.

[jpienaar]

mlir/include/mlir/Conversion/LLVMCommon/Pattern.h

171–174

What about making this one consistent with the one below?

[rriddle]

Resolve comments

mlir/include/mlir/Conversion/LLVMCommon/Pattern.h

matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     return matchAndRewrite(cast<SourceOp>(op),
                            OpAdaptor(operands, op->getAttrDictionary()),
                            rewriter);
   }
 
   /// Rewrite and Match methods that operate on the SourceOp type. These must be
   /// overridden by the derived pattern class.
-  /// NOTICE: These methods are deprecated and will be removed. All new code
-  /// should use the adaptor methods below instead.
-  virtual void rewrite(SourceOp op, ArrayRef<Value> operands,
-                       ConversionPatternRewriter &rewriter) const {
-    llvm_unreachable("must override rewrite or matchAndRewrite");
-  }
-  virtual LogicalResult
-  matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
-                  ConversionPatternRewriter &rewriter) const {
-    if (succeeded(match(op))) {
-      rewrite(op, OpAdaptor(operands, op->getAttrDictionary()), rewriter);
-      return success();
-    }
-    return failure();
-  }
-
-  /// Rewrite and Match methods that operate on the SourceOp type. These must be
-  /// overridden by the derived pattern class.
   virtual LogicalResult match(SourceOp op) const {
     llvm_unreachable("must override match or matchAndRewrite");
   }
   virtual void rewrite(SourceOp op, OpAdaptor adaptor,
                        ConversionPatternRewriter &rewriter) const {
-    ValueRange operands = adaptor.getOperands();
-    rewrite(op,
-            ArrayRef<Value>(operands.getBase().get<const Value *>(),
-                            operands.size()),
-            rewriter);
+    llvm_unreachable("must override rewrite or matchAndRewrite");
   }
   virtual LogicalResult
   matchAndRewrite(SourceOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const {
-    ValueRange operands = adaptor.getOperands();
-    return matchAndRewrite(
-        op,
-        ArrayRef<Value>(operands.getBase().get<const Value *>(),
-                        operands.size()),
-        rewriter);
+    if (failed(match(op)))
+      return failure();
+    rewrite(op, adaptor, rewriter);
+    return success();
   }
 
 private:
   using ConvertToLLVMPattern::match;
   using ConvertToLLVMPattern::matchAndRewrite;
 };
 
 /// Generic implementation of one-to-one conversion from "SourceOp" to

mlir/include/mlir/Transforms/DialectConversion.h

 
 protected:
   /// See `RewritePattern::RewritePattern` for information on the other
   /// available constructors.
   using RewritePattern::RewritePattern;
   /// Construct a conversion pattern with the given converter, and forward the
   /// remaining arguments to RewritePattern.
   template <typename... Args>
-  ConversionPattern(TypeConverter &typeConverter, Args &&... args)
+  ConversionPattern(TypeConverter &typeConverter, Args &&...args)
       : RewritePattern(std::forward<Args>(args)...),
         typeConverter(&typeConverter) {}
 
 protected:
   /// An optional type converter for use by this pattern.
   TypeConverter *typeConverter = nullptr;
 
 private:
OpConversionPattern(MLIRContext *context, PatternBenefit benefit = 1)
       : ConversionPattern(SourceOp::getOperationName(), benefit, context) {}
   OpConversionPattern(TypeConverter &typeConverter, MLIRContext *context,
                       PatternBenefit benefit = 1)
       : ConversionPattern(typeConverter, SourceOp::getOperationName(), benefit,
                           context) {}
 
   /// Wrappers around the ConversionPattern methods that pass the derived op
   /// type.
+  LogicalResult match(Operation *op) const final {
+    return match(cast<SourceOp>(op));
+  }
   void rewrite(Operation *op, ArrayRef<Value> operands,
                ConversionPatternRewriter &rewriter) const final {
     rewrite(cast<SourceOp>(op), OpAdaptor(operands, op->getAttrDictionary()),
             rewriter);
   }
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     return matchAndRewrite(cast<SourceOp>(op),
                            OpAdaptor(operands, op->getAttrDictionary()),
                            rewriter);
   }
 
-  /// Rewrite and Match methods that operate on the SourceOp type and accept the
-  /// raw operand values.
-  /// NOTICE: These methods are deprecated and will be removed. All new code
-  /// should use the adaptor methods below instead.
-  virtual void rewrite(SourceOp op, ArrayRef<Value> operands,
-                       ConversionPatternRewriter &rewriter) const {
-    llvm_unreachable("must override matchAndRewrite or a rewrite method");
-  }
-  virtual LogicalResult
-  matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
-                  ConversionPatternRewriter &rewriter) const {
-    if (failed(match(op)))
-      return failure();
-    rewrite(op, OpAdaptor(operands, op->getAttrDictionary()), rewriter);
-    return success();
-  }
-
   /// Rewrite and Match methods that operate on the SourceOp type. These must be
   /// overridden by the derived pattern class.
+  virtual LogicalResult match(SourceOp op) const {
+    llvm_unreachable("must override match or matchAndRewrite");
+  }
   virtual void rewrite(SourceOp op, OpAdaptor adaptor,
                        ConversionPatternRewriter &rewriter) const {
-    ValueRange operands = adaptor.getOperands();
-    rewrite(op,
-            ArrayRef<Value>(operands.getBase().get<const Value *>(),
-                            operands.size()),
-            rewriter);
+    llvm_unreachable("must override matchAndRewrite or a rewrite method");
   }
   virtual LogicalResult
   matchAndRewrite(SourceOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const {
-    ValueRange operands = adaptor.getOperands();
-    return matchAndRewrite(
-        op,
-        ArrayRef<Value>(operands.getBase().get<const Value *>(),
-                        operands.size()),
-        rewriter);
+    if (failed(match(op)))
+      return failure();
+    rewrite(op, adaptor, rewriter);
+    return success();
   }
 
 private:
   using ConversionPattern::matchAndRewrite;
 };
 
 /// OpInterfaceConversionPattern is a wrapper around ConversionPattern that
 /// allows for matching and rewriting against an instance of an OpInterface