[mlir][NFC] update mlir/Dialect create APIs (28/n)

[makslevental]

See #147168 for more info.

[llvmbot]

@llvm/pr-subscribers-mlir-core
@llvm/pr-subscribers-mlir-func
@llvm/pr-subscribers-mlir-scf
@llvm/pr-subscribers-mlir-tosa

@llvm/pr-subscribers-mlir-arith

Author: Maksim Levental (makslevental)

Changes

See #147168 for more info.

---

Patch is 48.30 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/150641.diff

28 Files Affected:

• (modified) mlir/test/lib/Conversion/MathToVCIX/TestMathToVCIXConversion.cpp (+29-29)
• (modified) mlir/test/lib/Dialect/Affine/TestReifyValueBounds.cpp (+2-2)
• (modified) mlir/test/lib/Dialect/Arith/TestEmulateWideInt.cpp (+1-1)
• (modified) mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp (+2-2)
• (modified) mlir/test/lib/Dialect/SCF/TestSCFUtils.cpp (+5-5)
• (modified) mlir/test/lib/Dialect/SCF/TestWhileOpBuilder.cpp (+6-6)
• (modified) mlir/test/lib/Dialect/Tensor/TestTensorTransforms.cpp (+8-8)
• (modified) mlir/test/lib/Dialect/Test/TestDialect.cpp (+1-1)
• (modified) mlir/test/lib/Dialect/Test/TestDialectInterfaces.cpp (+3-3)
• (modified) mlir/test/lib/Dialect/Test/TestFromLLVMIRTranslation.cpp (+2-2)
• (modified) mlir/test/lib/Dialect/Test/TestOpDefs.cpp (+6-6)
• (modified) mlir/test/lib/Dialect/Test/TestOps.td (+3-3)
• (modified) mlir/test/lib/Dialect/Test/TestOpsSyntax.cpp (+2-2)
• (modified) mlir/test/lib/Dialect/Test/TestPatterns.cpp (+18-18)
• (modified) mlir/test/lib/Dialect/Test/TestToLLVMIRTranslation.cpp (+1-1)
• (modified) mlir/test/lib/Dialect/TestIRDLToCpp/TestIRDLToCppDialect.cpp (+1-1)
• (modified) mlir/test/lib/Dialect/Tosa/TosaTestPasses.cpp (+4-4)
• (modified) mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.cpp (+2-2)
• (modified) mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp (+6-6)
• (modified) mlir/test/lib/IR/TestPrintInvalid.cpp (+2-2)
• (modified) mlir/test/lib/IR/TestSlicing.cpp (+2-2)
• (modified) mlir/test/lib/Pass/TestPassManager.cpp (+1-1)
• (modified) mlir/test/lib/Transforms/TestDialectConversion.cpp (+1-1)
• (modified) mlir/test/lib/Transforms/TestInliningCallback.cpp (+3-3)
• (modified) mlir/test/lib/Transforms/TestMakeIsolatedFromAbove.cpp (+1-1)
• (modified) mlir/test/lib/Transforms/TestTransformsOps.cpp (+1-1)
• (modified) mlir/test/mlir-tblgen/rewriter-attributes-properties.td (+1-1)
• (modified) mlir/test/mlir-tblgen/rewriter-indexing.td (+1-1)

diff --git a/mlir/test/lib/Conversion/MathToVCIX/TestMathToVCIXConversion.cpp b/mlir/test/lib/Conversion/MathToVCIX/TestMathToVCIXConversion.cpp
index 8a01a0af59b22..eb2c267634985 100644
--- a/mlir/test/lib/Conversion/MathToVCIX/TestMathToVCIXConversion.cpp
+++ b/mlir/test/lib/Conversion/MathToVCIX/TestMathToVCIXConversion.cpp
@@ -69,24 +69,24 @@ struct MathCosToVCIX final : OpRewritePattern<math::CosOp> {
     if (legalType.isScalable())
       // Use arbitrary runtime vector length when vector type is scalable.
       // Proper conversion pass should take it from the IR.
-      rvl = rewriter.create<arith::ConstantOp>(loc,
+      rvl = arith::ConstantOp::create(rewriter,loc,
                                                rewriter.getI64IntegerAttr(9));
     Value res;
     if (n == 1) {
-      res = rewriter.create<vcix::BinaryImmOp>(loc, legalType, opcodeAttr, vec,
+      res = vcix::BinaryImmOp::create(rewriter,loc, legalType, opcodeAttr, vec,
                                                immAttr, rvl);
     } else {
       const unsigned eltCount = legalType.getShape()[0];
       Type eltTy = legalType.getElementType();
-      Value zero = rewriter.create<arith::ConstantOp>(
+      Value zero = arith::ConstantOp::create(rewriter,
           loc, eltTy, rewriter.getZeroAttr(eltTy));
-      res = rewriter.create<vector::BroadcastOp>(loc, opType, zero /*dummy*/);
+      res = vector::BroadcastOp::create(rewriter,loc, opType, zero /*dummy*/);
       for (unsigned i = 0; i < n; ++i) {
-        Value extracted = rewriter.create<vector::ScalableExtractOp>(
+        Value extracted = vector::ScalableExtractOp::create(rewriter,
             loc, legalType, vec, i * eltCount);
-        Value v = rewriter.create<vcix::BinaryImmOp>(loc, legalType, opcodeAttr,
+        Value v = vcix::BinaryImmOp::create(rewriter,loc, legalType, opcodeAttr,
                                                      extracted, immAttr, rvl);
-        res = rewriter.create<vector::ScalableInsertOp>(loc, v, res,
+        res = vector::ScalableInsertOp::create(rewriter,loc, v, res,
                                                         i * eltCount);
       }
     }
@@ -112,24 +112,24 @@ struct MathSinToVCIX final : OpRewritePattern<math::SinOp> {
     if (legalType.isScalable())
       // Use arbitrary runtime vector length when vector type is scalable.
       // Proper conversion pass should take it from the IR.
-      rvl = rewriter.create<arith::ConstantOp>(loc,
+      rvl = arith::ConstantOp::create(rewriter,loc,
                                                rewriter.getI64IntegerAttr(9));
     Value res;
     if (n == 1) {
-      res = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr, vec,
+      res = vcix::BinaryOp::create(rewriter,loc, legalType, opcodeAttr, vec,
                                             vec, rvl);
     } else {
       const unsigned eltCount = legalType.getShape()[0];
       Type eltTy = legalType.getElementType();
-      Value zero = rewriter.create<arith::ConstantOp>(
+      Value zero = arith::ConstantOp::create(rewriter,
           loc, eltTy, rewriter.getZeroAttr(eltTy));
-      res = rewriter.create<vector::BroadcastOp>(loc, opType, zero /*dummy*/);
+      res = vector::BroadcastOp::create(rewriter,loc, opType, zero /*dummy*/);
       for (unsigned i = 0; i < n; ++i) {
-        Value extracted = rewriter.create<vector::ScalableExtractOp>(
+        Value extracted = vector::ScalableExtractOp::create(rewriter,
             loc, legalType, vec, i * eltCount);
-        Value v = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr,
+        Value v = vcix::BinaryOp::create(rewriter,loc, legalType, opcodeAttr,
                                                   extracted, extracted, rvl);
-        res = rewriter.create<vector::ScalableInsertOp>(loc, v, res,
+        res = vector::ScalableInsertOp::create(rewriter,loc, v, res,
                                                         i * eltCount);
       }
     }
@@ -152,27 +152,27 @@ struct MathTanToVCIX final : OpRewritePattern<math::TanOp> {
     Location loc = op.getLoc();
     Value vec = op.getOperand();
     Attribute opcodeAttr = rewriter.getI64IntegerAttr(0);
-    Value zero = rewriter.create<arith::ConstantOp>(
+    Value zero = arith::ConstantOp::create(rewriter,
         loc, eltTy, rewriter.getZeroAttr(eltTy));
     Value rvl = nullptr;
     if (legalType.isScalable())
       // Use arbitrary runtime vector length when vector type is scalable.
       // Proper conversion pass should take it from the IR.
-      rvl = rewriter.create<arith::ConstantOp>(loc,
+      rvl = arith::ConstantOp::create(rewriter,loc,
                                                rewriter.getI64IntegerAttr(9));
     Value res;
     if (n == 1) {
-      res = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr, vec,
+      res = vcix::BinaryOp::create(rewriter,loc, legalType, opcodeAttr, vec,
                                             zero, rvl);
     } else {
       const unsigned eltCount = legalType.getShape()[0];
-      res = rewriter.create<vector::BroadcastOp>(loc, opType, zero /*dummy*/);
+      res = vector::BroadcastOp::create(rewriter,loc, opType, zero /*dummy*/);
       for (unsigned i = 0; i < n; ++i) {
-        Value extracted = rewriter.create<vector::ScalableExtractOp>(
+        Value extracted = vector::ScalableExtractOp::create(rewriter,
             loc, legalType, vec, i * eltCount);
-        Value v = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr,
+        Value v = vcix::BinaryOp::create(rewriter,loc, legalType, opcodeAttr,
                                                   extracted, zero, rvl);
-        res = rewriter.create<vector::ScalableInsertOp>(loc, v, res,
+        res = vector::ScalableInsertOp::create(rewriter,loc, v, res,
                                                         i * eltCount);
       }
     }
@@ -195,29 +195,29 @@ struct MathLogToVCIX final : OpRewritePattern<math::LogOp> {
     Value vec = op.getOperand();
     Attribute opcodeAttr = rewriter.getI64IntegerAttr(0);
     Value rvl = nullptr;
-    Value zeroInt = rewriter.create<arith::ConstantOp>(
+    Value zeroInt = arith::ConstantOp::create(rewriter,
         loc, rewriter.getI32Type(), rewriter.getI32IntegerAttr(0));
     if (legalType.isScalable())
       // Use arbitrary runtime vector length when vector type is scalable.
       // Proper conversion pass should take it from the IR.
-      rvl = rewriter.create<arith::ConstantOp>(loc,
+      rvl = arith::ConstantOp::create(rewriter,loc,
                                                rewriter.getI64IntegerAttr(9));
     Value res;
     if (n == 1) {
-      res = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr, vec,
+      res = vcix::BinaryOp::create(rewriter,loc, legalType, opcodeAttr, vec,
                                             zeroInt, rvl);
     } else {
       const unsigned eltCount = legalType.getShape()[0];
       Type eltTy = legalType.getElementType();
-      Value zero = rewriter.create<arith::ConstantOp>(
+      Value zero = arith::ConstantOp::create(rewriter,
           loc, eltTy, rewriter.getZeroAttr(eltTy));
-      res = rewriter.create<vector::BroadcastOp>(loc, opType, zero /*dummy*/);
+      res = vector::BroadcastOp::create(rewriter,loc, opType, zero /*dummy*/);
       for (unsigned i = 0; i < n; ++i) {
-        Value extracted = rewriter.create<vector::ScalableExtractOp>(
+        Value extracted = vector::ScalableExtractOp::create(rewriter,
             loc, legalType, vec, i * eltCount);
-        Value v = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr,
+        Value v = vcix::BinaryOp::create(rewriter,loc, legalType, opcodeAttr,
                                                   extracted, zeroInt, rvl);
-        res = rewriter.create<vector::ScalableInsertOp>(loc, v, res,
+        res = vector::ScalableInsertOp::create(rewriter,loc, v, res,
                                                         i * eltCount);
       }
     }
diff --git a/mlir/test/lib/Dialect/Affine/TestReifyValueBounds.cpp b/mlir/test/lib/Dialect/Affine/TestReifyValueBounds.cpp
index ed5d06d925e31..190d483be4f7a 100644
--- a/mlir/test/lib/Dialect/Affine/TestReifyValueBounds.cpp
+++ b/mlir/test/lib/Dialect/Affine/TestReifyValueBounds.cpp
@@ -145,7 +145,7 @@ static LogicalResult testReifyValueBounds(FunctionOpInterface funcOp,
         if (reifiedScalable->map.getNumInputs() == 1) {
           // The only possible input to the bound is vscale.
           vscaleOperand.push_back(std::make_pair(
-              rewriter.create<vector::VectorScaleOp>(loc), std::nullopt));
+              vector::VectorScaleOp::create(rewriter,loc), std::nullopt));
         }
         reified = affine::materializeComputedBound(
             rewriter, loc, reifiedScalable->map, vscaleOperand);
@@ -169,7 +169,7 @@ static LogicalResult testReifyValueBounds(FunctionOpInterface funcOp,
       rewriter.replaceOp(op, val);
       return WalkResult::skip();
     }
-    Value constOp = rewriter.create<arith::ConstantIndexOp>(
+    Value constOp = arith::ConstantIndexOp::create(rewriter,
         op->getLoc(), cast<IntegerAttr>(cast<Attribute>(*reified)).getInt());
     rewriter.replaceOp(op, constOp);
     return WalkResult::skip();
diff --git a/mlir/test/lib/Dialect/Arith/TestEmulateWideInt.cpp b/mlir/test/lib/Dialect/Arith/TestEmulateWideInt.cpp
index 738d4ee59cbde..4c5ba946cd721 100644
--- a/mlir/test/lib/Dialect/Arith/TestEmulateWideInt.cpp
+++ b/mlir/test/lib/Dialect/Arith/TestEmulateWideInt.cpp
@@ -60,7 +60,7 @@ struct TestEmulateWideIntPass
     // casts (and vice versa) and using it insted of `llvm.bitcast`.
     auto addBitcast = [](OpBuilder &builder, Type type, ValueRange inputs,
                          Location loc) -> Value {
-      auto cast = builder.create<LLVM::BitcastOp>(loc, type, inputs);
+      auto cast = LLVM::BitcastOp::create(builder,loc, type, inputs);
       return cast->getResult(0);
     };
     typeConverter.addSourceMaterialization(addBitcast);
diff --git a/mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp b/mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp
index d0b62e71ab0cf..362fd1a3b2873 100644
--- a/mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp
+++ b/mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp
@@ -48,7 +48,7 @@ static SmallVector<Value> buildDecomposeTuple(OpBuilder &builder,
     }
     for (unsigned i = 0, e = tupleType.size(); i < e; ++i) {
       Type elementType = tupleType.getType(i);
-      Value element = builder.create<test::GetTupleElementOp>(
+      Value element = test::GetTupleElementOp::create(builder,
           loc, elementType, tuple, builder.getI32IntegerAttr(i));
       decompose(element);
     }
@@ -94,7 +94,7 @@ static Value buildMakeTupleOp(OpBuilder &builder, TupleType resultType,
   }
 
   // Assemble the tuple from the elements.
-  return builder.create<test::MakeTupleOp>(loc, resultType, elements);
+  return test::MakeTupleOp::create(builder,loc, resultType, elements);
 }
 
 /// A pass for testing call graph type decomposition.
diff --git a/mlir/test/lib/Dialect/SCF/TestSCFUtils.cpp b/mlir/test/lib/Dialect/SCF/TestSCFUtils.cpp
index 9eade75ac3163..a3231f3d1131d 100644
--- a/mlir/test/lib/Dialect/SCF/TestSCFUtils.cpp
+++ b/mlir/test/lib/Dialect/SCF/TestSCFUtils.cpp
@@ -56,7 +56,7 @@ struct TestSCFForUtilsPass
           SmallVector<Value> newYieldValues;
           for (auto yieldVal : oldYieldValues) {
             newYieldValues.push_back(
-                b.create<arith::AddFOp>(loc, yieldVal, yieldVal));
+                arith::AddFOp::create(b,loc, yieldVal, yieldVal));
           }
           return newYieldValues;
         };
@@ -160,13 +160,13 @@ struct TestSCFPipeliningPass
                                 Value pred) {
     Location loc = op->getLoc();
     auto ifOp =
-        rewriter.create<scf::IfOp>(loc, op->getResultTypes(), pred, true);
+        scf::IfOp::create(rewriter,loc, op->getResultTypes(), pred, true);
     // True branch.
     rewriter.moveOpBefore(op, &ifOp.getThenRegion().front(),
                           ifOp.getThenRegion().front().begin());
     rewriter.setInsertionPointAfter(op);
     if (op->getNumResults() > 0)
-      rewriter.create<scf::YieldOp>(loc, op->getResults());
+      scf::YieldOp::create(rewriter,loc, op->getResults());
     // False branch.
     rewriter.setInsertionPointToStart(&ifOp.getElseRegion().front());
     SmallVector<Value> elseYieldOperands;
@@ -181,12 +181,12 @@ struct TestSCFPipeliningPass
     } else {
       // Default to assuming constant numeric values.
       for (Type type : op->getResultTypes()) {
-        elseYieldOperands.push_back(rewriter.create<arith::ConstantOp>(
+        elseYieldOperands.push_back(arith::ConstantOp::create(rewriter,
             loc, rewriter.getZeroAttr(type)));
       }
     }
     if (op->getNumResults() > 0)
-      rewriter.create<scf::YieldOp>(loc, elseYieldOperands);
+      scf::YieldOp::create(rewriter,loc, elseYieldOperands);
     return ifOp.getOperation();
   }
 
diff --git a/mlir/test/lib/Dialect/SCF/TestWhileOpBuilder.cpp b/mlir/test/lib/Dialect/SCF/TestWhileOpBuilder.cpp
index d3113c0b0ae7d..f5f361ef6eadc 100644
--- a/mlir/test/lib/Dialect/SCF/TestWhileOpBuilder.cpp
+++ b/mlir/test/lib/Dialect/SCF/TestWhileOpBuilder.cpp
@@ -50,23 +50,23 @@ struct TestSCFWhileOpBuilderPass
       // Create a WhileOp with the same operands and result types.
       TypeRange resultTypes = whileOp->getResultTypes();
       ValueRange operands = whileOp->getOperands();
-      builder.create<WhileOp>(
+      WhileOp::create(builder,
           loc, resultTypes, operands, /*beforeBuilder=*/
           [&](OpBuilder &b, Location loc, ValueRange args) {
             // Just cast the before args into the right types for condition.
             ImplicitLocOpBuilder builder(loc, b);
             auto castOp =
-                builder.create<UnrealizedConversionCastOp>(resultTypes, args);
-            auto cmp = builder.create<ConstantIntOp>(/*value=*/1, /*width=*/1);
-            builder.create<ConditionOp>(cmp, castOp->getResults());
+                UnrealizedConversionCastOp::create(builder,resultTypes, args);
+            auto cmp = ConstantIntOp::create(builder,/*value=*/1, /*width=*/1);
+            ConditionOp::create(builder,cmp, castOp->getResults());
           },
           /*afterBuilder=*/
           [&](OpBuilder &b, Location loc, ValueRange args) {
             // Just cast the after args into the right types for yield.
             ImplicitLocOpBuilder builder(loc, b);
-            auto castOp = builder.create<UnrealizedConversionCastOp>(
+            auto castOp = UnrealizedConversionCastOp::create(builder,
                 operands.getTypes(), args);
-            builder.create<YieldOp>(castOp->getResults());
+            YieldOp::create(builder,castOp->getResults());
           });
     });
   }
diff --git a/mlir/test/lib/Dialect/Tensor/TestTensorTransforms.cpp b/mlir/test/lib/Dialect/Tensor/TestTensorTransforms.cpp
index 0e191c32f009e..de1e09a1434fa 100644
--- a/mlir/test/lib/Dialect/Tensor/TestTensorTransforms.cpp
+++ b/mlir/test/lib/Dialect/Tensor/TestTensorTransforms.cpp
@@ -192,7 +192,7 @@ struct RewriteExtractSliceFromCollapseShapeBase
     // Create the destination tensor using the above values.
     Type elementType = op.getSourceType().getElementType();
     SmallVector<OpFoldResult> outputShape = reifiedShapes[0];
-    Value dest = rewriter.create<tensor::EmptyOp>(op->getLoc(), outputShape,
+    Value dest = tensor::EmptyOp::create(rewriter,op->getLoc(), outputShape,
                                                   elementType);
 
     // Calculate the parameters for the tile loop nest.
@@ -215,8 +215,8 @@ struct RewriteExtractSliceFromCollapseShapeUsingScfFor
                                 PatternRewriter &rewriter) const override {
     Location loc = op.getLoc();
     const unsigned numTiledDims = helper.getIterationSpaceSizes().size();
-    auto zero = rewriter.create<arith::ConstantIndexOp>(loc, 0);
-    auto one = rewriter.create<arith::ConstantIndexOp>(loc, 1);
+    auto zero = arith::ConstantIndexOp::create(rewriter,loc, 0);
+    auto one = arith::ConstantIndexOp::create(rewriter,loc, 1);
     SmallVector<Value> lbs(numTiledDims, zero);
     SmallVector<Value> steps(numTiledDims, one);
 
@@ -228,7 +228,7 @@ struct RewriteExtractSliceFromCollapseShapeUsingScfFor
               helper.emitLoopNestBody(nestedBuilder, loc, outputIvs);
 
           // Insert the slice into the destination.
-          return {nestedBuilder.create<tensor::InsertSliceOp>(
+          return {tensor::InsertSliceOp::create(nestedBuilder,
               loc, tile, iterArgs[0], insertParams)};
         });
     rewriter.replaceOp(op, nest.results);
@@ -245,7 +245,7 @@ struct RewriteExtractSliceFromCollapseShapeUsingScfForeach
                                 tensor::ExtractSliceFromCollapseHelper &helper,
                                 PatternRewriter &rewriter) const override {
     Location loc = op.getLoc();
-    auto forallOp = rewriter.create<scf::ForallOp>(
+    auto forallOp = scf::ForallOp::create(rewriter,
         loc, /*numThreads=*/getAsOpFoldResult(helper.getIterationSpaceSizes()),
         /*outputs=*/dest,
         /*mapping=*/std::nullopt,
@@ -261,9 +261,9 @@ struct RewriteExtractSliceFromCollapseShapeUsingScfForeach
           auto [tile, insertParams] =
               helper.emitLoopNestBody(nestedBuilder, loc, outputIvs);
           // Insert the slice into the destination.
-          auto term = nestedBuilder.create<scf::InParallelOp>(loc);
+          auto term = scf::InParallelOp::create(nestedBuilder,loc);
           nestedBuilder.setInsertionPointToStart(term.getBody());
-          nestedBuilder.create<tensor::ParallelInsertSliceOp>(
+          tensor::ParallelInsertSliceOp::create(nestedBuilder,
               loc, tile, outputArgs[0], insertParams);
         });
     rewriter.replaceOp(op, forallOp->getResult(0));
@@ -355,7 +355,7 @@ static LogicalResult testTrackingListenerReplacements(Operation *rootOp) {
   MLIRContext *context = rootOp->getContext();
   OpBuilder builder(context);
   OwningOpRef<transform::NamedSequenceOp> transformOp =
-      builder.create<transform::NamedSequenceOp>(
+      transform::NamedSequenceOp::create(builder,
           rootOp->getLoc(),
           /*sym_name=*/"test_sequence",
           /*function_type=*/
diff --git a/mlir/test/lib/Dialect/Test/TestDialect.cpp b/mlir/test/lib/Dialect/Test/TestDialect.cpp
index 1bbf2cc7481d9..e1c151201414b 100644
--- a/mlir/test/lib/Dialect/Test/TestDialect.cpp
+++ b/mlir/test/lib/Dialect/Test/TestDialect.cpp
@@ -346,7 +346,7 @@ TestDialect::~TestDialect() {
 
 Operation *TestDialect::materializeConstant(OpBuilder &builder, Attribute value,
                                             Type type, Location loc) {
-  return builder.create<TestOpConstant>(loc, type, value);
+  return TestOpConstant::create(builder,loc, type, value);
 }
 
 void *TestDialect::getRegisteredInterfaceForOp(TypeID typeID,
diff --git a/mlir/test/lib/Dialect/Test/TestDialectInterfaces.cpp b/mlir/test/lib/Dialect/Test/TestDialectInterfaces.cpp
index 01ae245e06e5a..859c6de31ef1a 100644
--- a/mlir/test/lib/Dialect/Test/TestDialectInterfaces.cpp
+++ b/mlir/test/lib/Dialect/Test/TestDialectInterfaces.cpp
@@ -354,7 +354,7 @@ struct TestInlinerInterface : public DialectInlinerInterface {
         !(input.getType().isSignlessInteger(16) ||
           input.getType().isSignlessInteger(32)))
       return nullptr;
-    return builder.create<TestCastOp>(conversionLoc, resultType, input);
+    return TestCastOp::create(builder,conversionLoc, resultType, input);
   }
 
   Value handleArgument(OpBuilder &builder, Operation *call, Operation *callable,
@@ -362,7 +362,7 @@ struct TestInlinerInterface : public DialectInlinerInterface {
                        DictionaryAttr argumentAttrs) const final {
     if (!argumentAttrs.contains("test.handle_argument"))
       return argument;
-    return builder.create<TestTypeChangerOp>(call->getLoc(), argument.getType(),
+    return TestTypeChangerOp::create(builder,call->getLoc(), argument.getType(),
                                              argument);
   }
 
@@ -370,7 +370,7 @@ struct TestInlinerInterface : public DialectInlinerInterface {
                      Value result, Di...
[truncated]

[github-actions]

✅ With the latest revision this PR passed the C/C++ code formatter.