1 files changed, 16 insertions, 16 deletions

diff --git a/mlir/lib/Conversion/BufferizationToMemRef/BufferizationToMemRef.cpp b/mlir/lib/Conversion/BufferizationToMemRef/BufferizationToMemRef.cpp
index b9991f3..3edcbb8 100644
--- a/mlir/lib/Conversion/BufferizationToMemRef/BufferizationToMemRef.cpp
+++ b/mlir/lib/Conversion/BufferizationToMemRef/BufferizationToMemRef.cpp
@@ -47,30 +47,29 @@ struct CloneOpConversion : public OpConversionPattern<bufferization::CloneOp> {
 
     if (auto unrankedType = dyn_cast<UnrankedMemRefType>(type)) {
       // Constants
-      Value zero = rewriter.create<arith::ConstantIndexOp>(loc, 0);
-      Value one = rewriter.create<arith::ConstantIndexOp>(loc, 1);
+      Value zero = arith::ConstantIndexOp::create(rewriter, loc, 0);
+      Value one = arith::ConstantIndexOp::create(rewriter, loc, 1);
 
       // Dynamically evaluate the size and shape of the unranked memref
-      Value rank = rewriter.create<memref::RankOp>(loc, op.getInput());
+      Value rank = memref::RankOp::create(rewriter, loc, op.getInput());
       MemRefType allocType =
           MemRefType::get({ShapedType::kDynamic}, rewriter.getIndexType());
-      Value shape = rewriter.create<memref::AllocaOp>(loc, allocType, rank);
+      Value shape = memref::AllocaOp::create(rewriter, loc, allocType, rank);
 
       // Create a loop to query dimension sizes, store them as a shape, and
       // compute the total size of the memref
       auto loopBody = [&](OpBuilder &builder, Location loc, Value i,
                           ValueRange args) {
         auto acc = args.front();
-        auto dim = rewriter.create<memref::DimOp>(loc, op.getInput(), i);
+        auto dim = memref::DimOp::create(rewriter, loc, op.getInput(), i);
 
-        rewriter.create<memref::StoreOp>(loc, dim, shape, i);
-        acc = rewriter.create<arith::MulIOp>(loc, acc, dim);
+        memref::StoreOp::create(rewriter, loc, dim, shape, i);
+        acc = arith::MulIOp::create(rewriter, loc, acc, dim);
 
-        rewriter.create<scf::YieldOp>(loc, acc);
+        scf::YieldOp::create(rewriter, loc, acc);
       };
-      auto size = rewriter
-                      .create<scf::ForOp>(loc, zero, rank, one, ValueRange(one),
-                                          loopBody)
+      auto size = scf::ForOp::create(rewriter, loc, zero, rank, one,
+                                     ValueRange(one), loopBody)
                       .getResult(0);
 
       MemRefType memrefType = MemRefType::get({ShapedType::kDynamic},
@@ -78,9 +77,9 @@ struct CloneOpConversion : public OpConversionPattern<bufferization::CloneOp> {
 
       // Allocate new memref with 1D dynamic shape, then reshape into the
       // shape of the original unranked memref
-      alloc = rewriter.create<memref::AllocOp>(loc, memrefType, size);
+      alloc = memref::AllocOp::create(rewriter, loc, memrefType, size);
       alloc =
-          rewriter.create<memref::ReshapeOp>(loc, unrankedType, alloc, shape);
+          memref::ReshapeOp::create(rewriter, loc, unrankedType, alloc, shape);
     } else {
       MemRefType memrefType = cast<MemRefType>(type);
       MemRefLayoutAttrInterface layout;
@@ -103,14 +102,15 @@ struct CloneOpConversion : public OpConversionPattern<bufferization::CloneOp> {
       }
 
       // Allocate a memref with identity layout.
-      alloc = rewriter.create<memref::AllocOp>(loc, allocType, dynamicOperands);
+      alloc =
+          memref::AllocOp::create(rewriter, loc, allocType, dynamicOperands);
       // Cast the allocation to the specified type if needed.
       if (memrefType != allocType)
         alloc =
-            rewriter.create<memref::CastOp>(op->getLoc(), memrefType, alloc);
+            memref::CastOp::create(rewriter, op->getLoc(), memrefType, alloc);
     }
 
-    rewriter.create<memref::CopyOp>(loc, op.getInput(), alloc);
+    memref::CopyOp::create(rewriter, loc, op.getInput(), alloc);
     rewriter.replaceOp(op, alloc);
     return success();
   }