[mlir][NFC] update mlir create APIs (34/n) (#150660)

See https://github.com/llvm/llvm-project/pull/147168 for more info.

mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp

@@ -402,8 +402,8 @@ public:
     Value actualOp = adaptValueType(adaptor.getIn(), rewriter, castSrcType);
 
     // Actual cast (may change bitwidth)
-    auto cast = rewriter.template create<emitc::CastOp>(op.getLoc(),
+    auto cast =
-                                                        castDestType, actualOp);
+        emitc::CastOp::create(rewriter, op.getLoc(), castDestType, actualOp);
 
     // Cast to the expected output type
     auto result = adaptValueType(cast, rewriter, opReturnType);
@@ -507,8 +507,8 @@ public:
     Value lhs = adaptValueType(adaptor.getLhs(), rewriter, arithmeticType);
     Value rhs = adaptValueType(adaptor.getRhs(), rewriter, arithmeticType);
 
-    Value arithmeticResult = rewriter.template create<EmitCOp>(
+    Value arithmeticResult =
-        op.getLoc(), arithmeticType, lhs, rhs);
+        EmitCOp::create(rewriter, op.getLoc(), arithmeticType, lhs, rhs);
 
     Value result = adaptValueType(arithmeticResult, rewriter, type);
 
@@ -547,8 +547,8 @@ public:
     Value lhs = adaptValueType(adaptor.getLhs(), rewriter, arithmeticType);
     Value rhs = adaptValueType(adaptor.getRhs(), rewriter, arithmeticType);
 
-    Value arithmeticResult = rewriter.template create<EmitCOp>(
+    Value arithmeticResult =
-        op.getLoc(), arithmeticType, lhs, rhs);
+        EmitCOp::create(rewriter, op.getLoc(), arithmeticType, lhs, rhs);
 
     Value result = adaptValueType(arithmeticResult, rewriter, type);
 
@@ -748,8 +748,8 @@ public:
     }
     Value fpCastOperand = adaptor.getIn();
     if (actualOperandType != operandType) {
-      fpCastOperand = rewriter.template create<emitc::CastOp>(
+      fpCastOperand = emitc::CastOp::create(rewriter, castOp.getLoc(),
-          castOp.getLoc(), actualOperandType, fpCastOperand);
+                                            actualOperandType, fpCastOperand);
     }
     rewriter.replaceOpWithNewOp<emitc::CastOp>(castOp, dstType, fpCastOperand);
 

mlir/lib/Conversion/BufferizationToMemRef/BufferizationToMemRef.cpp

@@ -68,9 +68,8 @@ struct CloneOpConversion : public OpConversionPattern<bufferization::CloneOp> {
 
         scf::YieldOp::create(rewriter, loc, acc);
       };
-      auto size = rewriter
+      auto size = scf::ForOp::create(rewriter, loc, zero, rank, one,
-                      .create<scf::ForOp>(loc, zero, rank, one, ValueRange(one),
+                                     ValueRange(one), loopBody)
-                                          loopBody)
                       .getResult(0);
 
       MemRefType memrefType = MemRefType::get({ShapedType::kDynamic},

mlir/lib/Conversion/ControlFlowToSCF/ControlFlowToSCF.cpp

@@ -144,12 +144,11 @@ ControlFlowToSCFTransformation::createUnreachableTerminator(Location loc,
     return emitError(loc, "Cannot create unreachable terminator for '")
            << parentOp->getName() << "'";
 
-  return builder
+  return func::ReturnOp::create(
-      .create<func::ReturnOp>(
+             builder, loc,
-          loc, llvm::map_to_vector(funcOp.getResultTypes(),
+             llvm::map_to_vector(
-                                   [&](Type type) {
+                 funcOp.getResultTypes(),
-                                     return getUndefValue(loc, builder, type);
+                 [&](Type type) { return getUndefValue(loc, builder, type); }))
-                                   }))
       .getOperation();
 }
 

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.cpp

@@ -559,8 +559,8 @@ static Value createGroupReduceOpImpl(OpBuilder &builder, Location loc,
         builder, loc, builder.getI32Type(),
         builder.getIntegerAttr(builder.getI32Type(), *clusterSize));
 
-  return builder
+  return NonUniformOp::create(builder, loc, type, scope, groupOp, arg,
-      .create<NonUniformOp>(loc, type, scope, groupOp, arg, clusterSizeValue)
+                              clusterSizeValue)
       .getResult();
 }
 

mlir/lib/Conversion/LLVMCommon/Pattern.cpp

@@ -272,9 +272,8 @@ LogicalResult ConvertToLLVMPattern::copyUnrankedDescriptors(
 
     // Allocate memory, copy, and free the source if necessary.
     Value memory =
-        toDynamic
+        toDynamic ? LLVM::CallOp::create(builder, loc, mallocFunc.value(),
-            ? builder
+                                         allocationSize)
-                  .create<LLVM::CallOp>(loc, mallocFunc.value(), allocationSize)
                         .getResult()
                   : LLVM::AllocaOp::create(builder, loc, getPtrType(),
                                            IntegerType::get(getContext(), 8),

mlir/lib/Conversion/MPIToLLVM/MPIToLLVM.cpp

@@ -35,7 +35,7 @@ static Op getOrDefineGlobal(ModuleOp &moduleOp, const Location loc,
   if (!(ret = moduleOp.lookupSymbol<Op>(name))) {
     ConversionPatternRewriter::InsertionGuard guard(rewriter);
     rewriter.setInsertionPointToStart(moduleOp.getBody());
-    ret = rewriter.template create<Op>(loc, std::forward<Args>(args)...);
+    ret = Op::create(rewriter, loc, std::forward<Args>(args)...);
   }
   return ret;
 }

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

@@ -575,8 +575,8 @@ private:
     Value sizePtr = LLVM::GEPOp::create(rewriter, loc, indexPtrTy,
                                         getTypeConverter()->getIndexType(),
                                         offsetPtr, idxPlusOne);
-    return rewriter
+    return LLVM::LoadOp::create(rewriter, loc,
-        .create<LLVM::LoadOp>(loc, getTypeConverter()->getIndexType(), sizePtr)
+                                getTypeConverter()->getIndexType(), sizePtr)
         .getResult();
   }
 

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

@@ -1493,11 +1493,11 @@ public:
     Value extended;
     if (op2TypeWidth < dstTypeWidth) {
       if (isUnsignedIntegerOrVector(op2Type)) {
-        extended = rewriter.template create<LLVM::ZExtOp>(
+        extended =
-            loc, dstType, adaptor.getOperand2());
+            LLVM::ZExtOp::create(rewriter, loc, dstType, adaptor.getOperand2());
       } else {
-        extended = rewriter.template create<LLVM::SExtOp>(
+        extended =
-            loc, dstType, adaptor.getOperand2());
+            LLVM::SExtOp::create(rewriter, loc, dstType, adaptor.getOperand2());
       }
     } else if (op2TypeWidth == dstTypeWidth) {
       extended = adaptor.getOperand2();
@@ -1505,8 +1505,8 @@ public:
       return failure();
     }
 
-    Value result = rewriter.template create<LLVMOp>(
+    Value result =
-        loc, dstType, adaptor.getOperand1(), extended);
+        LLVMOp::create(rewriter, loc, dstType, adaptor.getOperand1(), extended);
     rewriter.replaceOp(op, result);
     return success();
   }

mlir/lib/Conversion/ShardToMPI/ShardToMPI.cpp

@@ -177,9 +177,8 @@ struct ConvertShardingOp : public OpConversionPattern<ShardingOp> {
     auto type = RankedTensorType::get({nSplits, 2}, i64);
     Value resHaloSizes =
         haloSizes.empty()
-            ? rewriter
+            ? tensor::EmptyOp::create(rewriter, loc,
-                  .create<tensor::EmptyOp>(loc, std::array<int64_t, 2>{0, 0},
+                                      std::array<int64_t, 2>{0, 0}, i64)
-                                           i64)
                   .getResult()
             : tensor::FromElementsOp::create(rewriter, loc, type, haloSizes)
                   .getResult();
@@ -306,10 +305,8 @@ public:
     auto ctx = op.getContext();
     Value commWorld =
         mpi::CommWorldOp::create(rewriter, loc, mpi::CommType::get(ctx));
-    auto rank =
+    auto rank = mpi::CommRankOp::create(
-        rewriter
+                    rewriter, loc,
-            .create<mpi::CommRankOp>(
-                loc,
                     TypeRange{mpi::RetvalType::get(ctx), rewriter.getI32Type()},
                     commWorld)
                     .getRank();
@@ -703,9 +700,8 @@ struct ConvertUpdateHaloOp : public OpConversionPattern<UpdateHaloOp> {
     // subviews need Index values
     for (auto &sz : haloSizes) {
       if (auto value = dyn_cast<Value>(sz))
-        sz =
+        sz = arith::IndexCastOp::create(rewriter, loc, rewriter.getIndexType(),
-            rewriter
+                                        value)
-                .create<arith::IndexCastOp>(loc, rewriter.getIndexType(), value)
                  .getResult();
     }
 
@@ -758,9 +754,8 @@ struct ConvertUpdateHaloOp : public OpConversionPattern<UpdateHaloOp> {
       assert(currHaloDim >= 0 && (size_t)currHaloDim < haloSizes.size() / 2);
       // Get the linearized ids of the neighbors (down and up) for the
       // given split
-      auto tmp = rewriter
+      auto tmp = NeighborsLinearIndicesOp::create(rewriter, loc, grid,
-                     .create<NeighborsLinearIndicesOp>(loc, grid, myMultiIndex,
+                                                  myMultiIndex, splitAxes)
-                                                       splitAxes)
                      .getResults();
       // MPI operates on i32...
       Value neighbourIDs[2] = {

mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp

@@ -569,10 +569,9 @@ static Value createLinalgBodyCalculationForElementwiseOp(
     // to UIToFP.
     if (srcTy.isUnsignedInteger() && isa<FloatType>(dstTy)) {
       auto unrealizedCast =
-          rewriter
+          UnrealizedConversionCastOp::create(
-              .create<UnrealizedConversionCastOp>(
+              rewriter, loc,
-                  loc, rewriter.getIntegerType(srcTy.getIntOrFloatBitWidth()),
+              rewriter.getIntegerType(srcTy.getIntOrFloatBitWidth()), args[0])
-                  args[0])
               .getResult(0);
       return arith::UIToFPOp::create(rewriter, loc, resultTypes[0],
                                      unrealizedCast);
@@ -868,10 +867,9 @@ static Value broadcastDynamicDimension(PatternRewriter &rewriter, Location loc,
 
     // Emit 'linalg.generic' op
     auto resultTensor =
-        opBuilder
+        linalg::GenericOp::create(
-            .create<linalg::GenericOp>(
+            opBuilder, loc, outputTensor.getType(), operand, outputTensor,
-                loc, outputTensor.getType(), operand, outputTensor, affineMaps,
+            affineMaps, getNParallelLoopsAttrs(rank),
-                getNParallelLoopsAttrs(rank),
             [&](OpBuilder &opBuilder, Location loc, ValueRange blockArgs) {
               // Emit 'linalg.yield' op
               linalg::YieldOp::create(opBuilder, loc, blockArgs.front());
@@ -1155,10 +1153,8 @@ static LogicalResult reduceMatchAndRewriteHelper(OpTy op, uint64_t axis,
   inputs.push_back(input);
 
   // First fill the output buffer with the init value.
-  auto emptyTensor =
+  auto emptyTensor = tensor::EmptyOp::create(rewriter, loc, reduceShape,
-      rewriter
+                                             resultTy.getElementType(), dynDims)
-          .create<tensor::EmptyOp>(loc, reduceShape, resultTy.getElementType(),
-                                   dynDims)
                          .getResult();
 
   auto fillValueAttr = createInitialValueForReduceOp(op, elementTy, rewriter);
@@ -1167,8 +1163,8 @@ static LogicalResult reduceMatchAndRewriteHelper(OpTy op, uint64_t axis,
         op, "No initial value found for reduction operation");
 
   auto fillValue = arith::ConstantOp::create(rewriter, loc, fillValueAttr);
-  auto filledTensor = rewriter
+  auto filledTensor =
-                          .create<linalg::FillOp>(loc, ValueRange{fillValue},
+      linalg::FillOp::create(rewriter, loc, ValueRange{fillValue},
                              ValueRange{emptyTensor})
           .result();
   outputs.push_back(filledTensor);
@@ -1186,13 +1182,11 @@ static LogicalResult reduceMatchAndRewriteHelper(OpTy op, uint64_t axis,
       auto trueAttr = rewriter.getBoolAttr(true);
       auto trueValue = arith::ConstantOp::create(rewriter, loc, trueAttr);
       auto emptyBoolTensor =
-          rewriter
+          tensor::EmptyOp::create(rewriter, loc, reduceShape,
-              .create<tensor::EmptyOp>(loc, reduceShape, trueValue.getType(),
+                                  trueValue.getType(), dynDims)
-                                       dynDims)
               .getResult();
       auto allResultsNaNTensor =
-          rewriter
+          linalg::FillOp::create(rewriter, loc, ValueRange{trueValue},
-              .create<linalg::FillOp>(loc, ValueRange{trueValue},
                                  ValueRange{emptyBoolTensor})
               .result();
       // Note that because the linalg::ReduceOp has two variadic arguments
@@ -1261,21 +1255,18 @@ static LogicalResult reduceMatchAndRewriteHelper(OpTy op, uint64_t axis,
         APFloat::getNaN(cast<FloatType>(elementTy).getFloatSemantics(), false));
     auto nanValue = arith::ConstantOp::create(rewriter, loc, nanValueAttr);
     auto emptyNanTensor =
-        rewriter
+        tensor::EmptyOp::create(rewriter, loc, reduceShape,
-            .create<tensor::EmptyOp>(loc, reduceShape,
                                 resultTy.getElementType(), dynDims)
             .getResult();
     auto nanFilledTensor =
-        rewriter
+        linalg::FillOp::create(rewriter, loc, ValueRange{nanValue},
-            .create<linalg::FillOp>(loc, ValueRange{nanValue},
                                ValueRange{emptyNanTensor})
             .result();
 
     // Create an empty tensor, non need to fill this since it will be
     // overwritten by the select.
     auto finalEmptyTensor =
-        rewriter
+        tensor::EmptyOp::create(rewriter, loc, reduceShape,
-            .create<tensor::EmptyOp>(loc, reduceShape,
                                 resultTy.getElementType(), dynDims)
             .getResult();
 
@@ -1503,9 +1494,8 @@ public:
           Value shift = shiftConstant ? shiftConstant : blockArgs[shiftArg];
 
           if (valueTy.isUnsignedInteger()) {
-            value = nestedBuilder
+            value = UnrealizedConversionCastOp::create(
-                        .create<UnrealizedConversionCastOp>(
+                        nestedBuilder, nestedLoc,
-                            nestedLoc,
                         nestedBuilder.getIntegerType(
                             valueTy.getIntOrFloatBitWidth()),
                         value)
@@ -1557,8 +1547,7 @@ public:
           }
 
           if (outIntType.isUnsignedInteger()) {
-            value = nestedBuilder
+            value = UnrealizedConversionCastOp::create(nestedBuilder, nestedLoc,
-                        .create<UnrealizedConversionCastOp>(nestedLoc,
                                                        outIntType, value)
                         .getResult(0);
           }
@@ -2095,10 +2084,9 @@ public:
     Value axisDimSize = tensor::DimOp::create(rewriter, loc, input, axis);
 
     // First fill the output buffer with the init value.
-    auto emptyTensor = rewriter
+    auto emptyTensor = tensor::EmptyOp::create(
-                           .create<tensor::EmptyOp>(loc, inputTy.getShape(),
+                           rewriter, loc, inputTy.getShape(),
-                                                    inputTy.getElementType(),
+                           inputTy.getElementType(), ArrayRef<Value>({dynDims}))
-                                                    ArrayRef<Value>({dynDims}))
                            .getResult();
     SmallVector<AffineMap, 2> affineMaps = {
         rewriter.getMultiDimIdentityMap(resultTy.getRank())};
@@ -2241,22 +2229,21 @@ public:
     }
 
     // First fill the output buffer for the index.
-    auto emptyTensorIdx = rewriter
+    auto emptyTensorIdx =
-                              .create<tensor::EmptyOp>(loc, resultTy.getShape(),
+        tensor::EmptyOp::create(rewriter, loc, resultTy.getShape(),
                                 outElementTy, dynDims)
             .getResult();
     auto fillValueIdx = arith::ConstantOp::create(
         rewriter, loc, rewriter.getIntegerAttr(outElementTy, 0));
     auto filledTensorIdx =
-        rewriter
+        linalg::FillOp::create(rewriter, loc, ValueRange{fillValueIdx},
-            .create<linalg::FillOp>(loc, ValueRange{fillValueIdx},
                                ValueRange{emptyTensorIdx})
             .result();
 
     // Second fill the output buffer for the running max.
-    auto emptyTensorMax = rewriter
+    auto emptyTensorMax =
-                              .create<tensor::EmptyOp>(loc, resultTy.getShape(),
+        tensor::EmptyOp::create(rewriter, loc, resultTy.getShape(), inElementTy,
-                                                       inElementTy, dynDims)
+                                dynDims)
             .getResult();
     auto fillValueMaxAttr =
         createInitialValueForReduceOp(argmaxOp, inElementTy, rewriter);
@@ -2268,8 +2255,7 @@ public:
     auto fillValueMax =
         arith::ConstantOp::create(rewriter, loc, fillValueMaxAttr);
     auto filledTensorMax =
-        rewriter
+        linalg::FillOp::create(rewriter, loc, ValueRange{fillValueMax},
-            .create<linalg::FillOp>(loc, ValueRange{fillValueMax},
                                ValueRange{emptyTensorMax})
             .result();
 
@@ -2371,9 +2357,8 @@ public:
 
     auto loc = op.getLoc();
     auto emptyTensor =
-        rewriter
+        tensor::EmptyOp::create(rewriter, loc, resultTy.getShape(),
-            .create<tensor::EmptyOp>(loc, resultTy.getShape(), resultElementTy,
+                                resultElementTy, dynamicDims)
-                                     dynamicDims)
             .getResult();
 
     SmallVector<AffineMap, 2> affineMaps = {
@@ -2448,8 +2433,8 @@ public:
       }
     }
 
-    auto emptyTensor = rewriter
+    auto emptyTensor =
-                           .create<tensor::EmptyOp>(loc, resultTy.getShape(),
+        tensor::EmptyOp::create(rewriter, loc, resultTy.getShape(),
                                 resultElementTy, dynDims)
             .getResult();
 
@@ -2585,8 +2570,8 @@ struct RFFT2dConverter final : public OpRewritePattern<RFFT2dOp> {
         tensor::EmptyOp::create(rewriter, loc, type, dynamicSizes);
     auto fillValueAttr = rewriter.getZeroAttr(type.getElementType());
     auto fillValue = arith::ConstantOp::create(rewriter, loc, fillValueAttr);
-    auto filledTensor = rewriter
+    auto filledTensor =
-                            .create<linalg::FillOp>(loc, ValueRange{fillValue},
+        linalg::FillOp::create(rewriter, loc, ValueRange{fillValue},
                                ValueRange{emptyTensor})
             .result();
     return filledTensor;

mlir/lib/Conversion/TosaToLinalg/TosaToLinalgNamed.cpp

@@ -64,17 +64,18 @@ linalgIntBroadcastExtSIAdd(PatternRewriter &rewriter, Location loc, Value bias,
                            Value conv, Value result,
                            ArrayRef<AffineMap> indexingMaps) {
   ShapedType resultTy = cast<ShapedType>(conv.getType());
-  return rewriter
+  return linalg::GenericOp::create(
-      .create<linalg::GenericOp>(
+             rewriter, loc, resultTy, ValueRange({bias, conv}), result,
-          loc, resultTy, ValueRange({bias, conv}), result, indexingMaps,
+             indexingMaps, getNParallelLoopsAttrs(resultTy.getRank()),
-          getNParallelLoopsAttrs(resultTy.getRank()),
              [](OpBuilder &builder, Location loc, ValueRange args) {
                Value biasVal = args[0];
                Type resType = args[1].getType();
                if (resType != biasVal.getType()) {
-              biasVal = arith::ExtSIOp::create(builder, loc, resType, biasVal);
+                 biasVal =
+                     arith::ExtSIOp::create(builder, loc, resType, biasVal);
                }
-            Value added = arith::AddIOp::create(builder, loc, biasVal, args[1]);
+               Value added =
+                   arith::AddIOp::create(builder, loc, biasVal, args[1]);
                linalg::YieldOp::create(builder, loc, added);
              })
       .getResult(0);
@@ -124,10 +125,9 @@ static mlir::Value linalgBroadcastAndMaybeExt(PatternRewriter &rewriter,
   indexingMaps.push_back(rewriter.getMultiDimIdentityMap(resultRank));
 
   // Build the broadcast-like operation as a linalg.generic.
-  return rewriter
+  return linalg::GenericOp::create(
-      .create<linalg::GenericOp>(
+             rewriter, loc, resultTy, ValueRange({source}), result,
-          loc, resultTy, ValueRange({source}), result, indexingMaps,
+             indexingMaps, getNParallelLoopsAttrs(resultTy.getRank()),
-          getNParallelLoopsAttrs(resultTy.getRank()),
              [&resultTy](OpBuilder &builder, Location loc, ValueRange args) {
                Value biasVal = args[0];
                Type resType = args[1].getType();
@@ -136,7 +136,8 @@ static mlir::Value linalgBroadcastAndMaybeExt(PatternRewriter &rewriter,
                      resultTy.getElementType().isFloat()
                          ? arith::ExtFOp::create(builder, loc, resType, biasVal)
                                .getResult()
-                      : arith::ExtSIOp::create(builder, loc, resType, biasVal)
+                         : arith::ExtSIOp::create(builder, loc, resType,
+                                                  biasVal)
                                .getResult();
                }
                linalg::YieldOp::create(builder, loc, biasVal);
@@ -397,10 +398,9 @@ public:
       auto iZpVal = arith::ConstantOp::create(rewriter, loc, iZp);
       auto kZpVal = arith::ConstantOp::create(rewriter, loc, kZp);
 
-      Value conv =
+      Value conv = LinalgConvQOp::create(
-          rewriter
+                       rewriter, loc, resultTy,
-              .create<LinalgConvQOp>(
+                       ValueRange{input, weight, iZpVal, kZpVal},
-                  loc, resultTy, ValueRange{input, weight, iZpVal, kZpVal},
                        ValueRange{broadcastBias}, strideAttr, dilationAttr)
                        ->getResult(0);
 
@@ -408,9 +408,8 @@ public:
       return success();
     }
 
-    Value conv = rewriter
+    Value conv = LinalgConvOp::create(
-                     .create<LinalgConvOp>(
+                     rewriter, loc, accTy, ValueRange{input, weight},
-                         loc, accTy, ValueRange{input, weight},
                      ValueRange{broadcastBias}, strideAttr, dilationAttr)
                      ->getResult(0);
 
@@ -529,8 +528,7 @@ public:
     Value emptyTensor = tensor::EmptyOp::create(
         rewriter, loc, linalgConvTy.getShape(), accETy, filteredDims);
     Value zero = arith::ConstantOp::create(rewriter, loc, resultZeroAttr);
-    Value zeroTensor = rewriter
+    Value zeroTensor = linalg::FillOp::create(rewriter, loc, ValueRange{zero},
-                           .create<linalg::FillOp>(loc, ValueRange{zero},
                                               ValueRange{emptyTensor})
                            .result();
 
@@ -544,9 +542,8 @@ public:
     indexingMaps.push_back(rewriter.getMultiDimIdentityMap(resultRank));
 
     if (hasNullZps) {
-      Value conv = rewriter
+      Value conv = linalg::DepthwiseConv2DNhwcHwcmOp::create(
-                       .create<linalg::DepthwiseConv2DNhwcHwcmOp>(
+                       rewriter, loc, linalgConvTy, ValueRange{input, weight},
-                           loc, linalgConvTy, ValueRange{input, weight},
                        ValueRange{zeroTensor}, strideAttr, dilationAttr)
                        .getResult(0);
 
@@ -565,11 +562,9 @@ public:
           rewriter, loc, resultTy, conv, reassociationMap);
 
       Value result =
-          rewriter
+          linalg::GenericOp::create(
-              .create<linalg::GenericOp>(
+              rewriter, loc, resultTy, ValueRange({bias, convReshape}),
-                  loc, resultTy, ValueRange({bias, convReshape}),
+              biasEmptyTensor, indexingMaps, getNParallelLoopsAttrs(resultRank),
-                  biasEmptyTensor, indexingMaps,
-                  getNParallelLoopsAttrs(resultRank),
               [&](OpBuilder &nestedBuilder, Location nestedLoc,
                   ValueRange args) {
                 Value added;
@@ -588,10 +583,9 @@ public:
       IntegerAttr wZp = rewriter.getI32IntegerAttr(weightZpVal);
       auto iZpVal = arith::ConstantOp::create(rewriter, loc, iZp);
       auto kZpVal = arith::ConstantOp::create(rewriter, loc, wZp);
-      Value conv =
+      Value conv = linalg::DepthwiseConv2DNhwcHwcmQOp::create(
-          rewriter
+                       rewriter, loc, linalgConvTy,
-              .create<linalg::DepthwiseConv2DNhwcHwcmQOp>(
+                       ValueRange{input, weight, iZpVal, kZpVal},
-                  loc, linalgConvTy, ValueRange{input, weight, iZpVal, kZpVal},
                        ValueRange{zeroTensor}, strideAttr, dilationAttr)
                        .getResult(0);
       SmallVector<ReassociationExprs, 4> reassociationMap;
@@ -639,8 +633,7 @@ public:
     auto emptyTensor =
         tensor::EmptyOp::create(rewriter, loc, outputTy.getShape(),
                                 outputTy.getElementType(), filteredDims);
-    Value zeroTensor = rewriter
+    Value zeroTensor = linalg::FillOp::create(rewriter, loc, ValueRange{zero},
-                           .create<linalg::FillOp>(loc, ValueRange{zero},
                                               ValueRange{emptyTensor})
                            .result();
 
@@ -910,8 +903,7 @@ public:
         rewriter, loc, accTy.getShape(), accETy, dynamicDims);
 
     Value filledEmptyTensor =
-        rewriter
+        linalg::FillOp::create(rewriter, loc, ValueRange{initialValue},
-            .create<linalg::FillOp>(loc, ValueRange{initialValue},
                                ValueRange{poolEmptyTensor})
             .result();
 
@@ -919,9 +911,8 @@ public:
         tensor::EmptyOp::create(rewriter, loc, kernel, accETy);
 
     // Sum across the pooled region.
-    Value poolingOp = rewriter
+    Value poolingOp = linalg::PoolingNhwcSumOp::create(
-                          .create<linalg::PoolingNhwcSumOp>(
+                          rewriter, loc, ArrayRef<Type>{accTy},
-                              loc, ArrayRef<Type>{accTy},
                           ValueRange{paddedInput, fakeWindowDims},
                           filledEmptyTensor, strideAttr, dilationAttr)
                           .getResult(0);
@@ -1050,10 +1041,9 @@ public:
             Value shift = arith::AddIOp::create(rewriter, loc, k8, thirty8);
 
             auto scaled =
-                rewriter
+                tosa::ApplyScaleOp::create(
-                    .create<tosa::ApplyScaleOp>(
+                    rewriter, loc, rewriter.getI32Type(), poolVal, multiplier,
-                        loc, rewriter.getI32Type(), poolVal, multiplier, shift,
+                    shift, rewriter.getStringAttr("SINGLE_ROUND"))
-                        rewriter.getStringAttr("SINGLE_ROUND"))
                     .getResult();
 
             // If we have quantization information we need to apply output

mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp

@@ -482,10 +482,8 @@ struct CombineTransferReadOpTranspose final
         permutationMap.compose(transferReadOp.getPermutationMap());
 
     auto loc = op.getLoc();
-    Value result =
+    Value result = vector::TransferReadOp::create(
-        rewriter
+                       rewriter, loc, resultType, transferReadOp.getBase(),
-            .create<vector::TransferReadOp>(
-                loc, resultType, transferReadOp.getBase(),
                        transferReadOp.getIndices(), AffineMapAttr::get(newMap),
                        transferReadOp.getPadding(), transferReadOp.getMask(),
                        transferReadOp.getInBoundsAttr())

mlir/lib/Target/LLVMIR/ModuleImport.cpp

@@ -142,6 +142,7 @@ static LogicalResult convertInstructionImpl(OpBuilder &odsBuilder,
   // TODO: Implement the `convertInstruction` hooks in the
   // `LLVMDialectLLVMIRImportInterface` and move the following include there.
 #include "mlir/Dialect/LLVMIR/LLVMOpFromLLVMIRConversions.inc"
+
   return failure();
 }
 
@@ -1626,9 +1627,8 @@ FailureOr<Value> ModuleImport::convertConstant(llvm::Constant *constant) {
   // Convert dso_local_equivalent.
   if (auto *dsoLocalEquivalent = dyn_cast<llvm::DSOLocalEquivalent>(constant)) {
     Type type = convertType(dsoLocalEquivalent->getType());
-    return builder
+    return DSOLocalEquivalentOp::create(
-        .create<DSOLocalEquivalentOp>(
+               builder, loc, type,
-            loc, type,
                FlatSymbolRefAttr::get(
                    builder.getContext(),
                    dsoLocalEquivalent->getGlobalValue()->getName()))
@@ -1736,8 +1736,8 @@ FailureOr<Value> ModuleImport::convertConstant(llvm::Constant *constant) {
         FlatSymbolRefAttr::get(context, blockAddr->getFunction()->getName());
     auto blockTag =
         BlockTagAttr::get(context, blockAddr->getBasicBlock()->getNumber());
-    return builder
+    return BlockAddressOp::create(
-        .create<BlockAddressOp>(loc, convertType(blockAddr->getType()),
+               builder, loc, convertType(blockAddr->getType()),
                BlockAddressAttr::get(context, fnSym, blockTag))
         .getRes();
   }
@@ -2228,9 +2228,8 @@ LogicalResult ModuleImport::convertInstruction(llvm::Instruction *inst) {
         if (!resultTy)
           return failure();
         ArrayAttr operandAttrs = convertAsmInlineOperandAttrs(*callInst);
-        return builder
+        return InlineAsmOp::create(
-            .create<InlineAsmOp>(
+                   builder, loc, resultTy, *operands,
-                loc, resultTy, *operands,
                    builder.getStringAttr(asmI->getAsmString()),
                    builder.getStringAttr(asmI->getConstraintString()),
                    asmI->hasSideEffects(), asmI->isAlignStack(),

mlir/test/lib/Dialect/Shard/TestReshardingPartition.cpp

@@ -72,15 +72,14 @@ struct TestReshardingRewritePattern : OpRewritePattern<ShardOp> {
       ShapedType sourceShardShape =
           shardShapedType(op.getResult().getType(), grid, op.getSharding());
       TypedValue<ShapedType> sourceShard = cast<TypedValue<ShapedType>>(
-          builder
+          UnrealizedConversionCastOp::create(builder, sourceShardShape,
-              .create<UnrealizedConversionCastOp>(sourceShardShape, op.getSrc())
+                                             op.getSrc())
               ->getResult(0));
       TypedValue<ShapedType> targetShard =
           reshard(builder, grid, op, targetShardOp, sourceShard);
       Value newTargetUnsharded =
-          builder
+          UnrealizedConversionCastOp::create(
-              .create<UnrealizedConversionCastOp>(
+              builder, targetShardOp.getResult().getType(), targetShard)
-                  targetShardOp.getResult().getType(), targetShard)
               ->getResult(0);
       rewriter.replaceAllUsesWith(targetShardOp.getResult(),
                                   newTargetUnsharded);

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

@@ -1007,8 +1007,7 @@ struct TestPassthroughInvalidOp : public ConversionPattern {
       // This is a 1:N replacement. Insert a test.cast op. (That's what the
       // argument materialization used to do.)
       flattened.push_back(
-          rewriter
+          TestCastOp::create(rewriter, op->getLoc(),
-              .create<TestCastOp>(op->getLoc(),
                              op->getOperand(it.index()).getType(), range)
               .getResult());
     }

mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp

@@ -569,8 +569,7 @@ static Value warpReduction(Location loc, OpBuilder &builder, Value input,
   Value laneVal = vector::ReductionOp::create(builder, loc, kind, input);
   // Parallel reduction using butterfly shuffles.
   for (uint64_t i = 1; i < size; i <<= 1) {
-    Value shuffled = builder
+    Value shuffled = gpu::ShuffleOp::create(builder, loc, laneVal, i,
-                         .create<gpu::ShuffleOp>(loc, laneVal, i,
                                             /*width=*/size,
                                             /*mode=*/gpu::ShuffleMode::XOR)
                          .getShuffleResult();
@@ -650,9 +649,8 @@ struct TestVectorDistribution
           arith::IndexCastOp::create(builder, loc, i32Type, srcIdx);
       Value warpSzI32 = arith::ConstantOp::create(
           builder, loc, builder.getIntegerAttr(i32Type, warpSz));
-      Value result = builder
+      Value result = gpu::ShuffleOp::create(builder, loc, val, srcIdxI32,
-                         .create<gpu::ShuffleOp>(loc, val, srcIdxI32, warpSzI32,
+                                            warpSzI32, gpu::ShuffleMode::IDX)
-                                                 gpu::ShuffleMode::IDX)
                          .getResult(0);
       return result;
     };