[mlir][nfc] Clean-up ConvertToDestinationStyle.cpp.

[jreiffers]

mlir/lib/Dialect/Linalg/Transforms/ConvertToDestinationStyle.cpp

371–375

I suppose it's not possible to change the argument order of the linalg function?

[nicolasvasilache]

mlir/lib/Dialect/Linalg/Transforms/ConvertToDestinationStyle.cpp

371–375

All functional-stye APIs should follow:

fun(builder, optional_loc, rest)

to be consistent with all the builder APIs and existing transform APIs.

The matchAndRewrite APIs are a special flower follow a different convention:

matchAndRewrite(rest, PatternRewriter &rewriter)

This convention is only in Rewrite/Conversion matchAndRewrite

mlir/lib/Dialect/Linalg/Transforms/ConvertToDestinationStyle.cpp

for (OpOperand *use : uses) {
     rewriter.updateRootInPlace(use->getOwner(),
                                [&]() { use->set(toTensorOp); });
   }
 
   return toTensorOp;
 }
 
 namespace {
-/// Lower tensor.from_elements to a sequence of chained tensor.insert.
-struct FromElementsOpConverter : public OpRewritePattern<FromElementsOp> {
-  using OpRewritePattern<FromElementsOp>::OpRewritePattern;
 
-  LogicalResult matchAndRewrite(FromElementsOp fromElementsOp,
-                                PatternRewriter &rewriter) const override {
-    if (failed(
-            linalg::rewriteInDestinationPassingStyle(rewriter, fromElementsOp)))
-      return failure();
-    return success();
-  }
-};
-
-/// Lower tensor.generate to linalg.generic.
-struct GenerateOpConverter : public OpRewritePattern<GenerateOp> {
-  using OpRewritePattern<GenerateOp>::OpRewritePattern;
+template <typename OpTy>
+LogicalResult rewriteOpInDestinationPassingStyle(OpTy op,
+                                                 PatternRewriter &rewriter) {
+  return linalg::rewriteInDestinationPassingStyle(rewriter, op);
 
-  LogicalResult matchAndRewrite(GenerateOp generateOp,
-                                PatternRewriter &rewriter) const override {
-    if (failed(linalg::rewriteInDestinationPassingStyle(rewriter, generateOp)))
-      return failure();
-    return success();
-  }
-};
-
-/// Lower tensor.pad to linalg.generic + tensor.insert_slice.
-struct PadOpConverter : public OpRewritePattern<PadOp> {
-  using OpRewritePattern<PadOp>::OpRewritePattern;
-
-  LogicalResult matchAndRewrite(PadOp padOp,
-                                PatternRewriter &rewriter) const override {
-    if (failed(linalg::rewriteInDestinationPassingStyle(rewriter, padOp)))
-      return failure();
-    return success();
-  }
-};
 } // namespace
 
 void linalg::populateConvertToDestinationStylePatterns(
     RewritePatternSet &patterns) {
-  patterns.insert<FromElementsOpConverter, GenerateOpConverter, PadOpConverter>(
-      patterns.getContext());
+  patterns.add(rewriteOpInDestinationPassingStyle<tensor::FromElementsOp>);
+  patterns.add(rewriteOpInDestinationPassingStyle<tensor::GenerateOp>);
+  patterns.add(rewriteOpInDestinationPassingStyle<tensor::PadOp>);
 }