Skip to content

Commit b58ad36

Browse files
maksleventalmakslevental
authored
[mlir][NFC] update mlir/Dialect create APIs (30/n) (llvm#150643)
See llvm#147168 for more info.
1 parent 258d04c commit b58ad36

File tree

10 files changed

+193
-194
lines changed

10 files changed

+193
-194
lines changed

‎mlir/unittests/Conversion/PDLToPDLInterp/RootOrderingTest.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,7 @@ class RootOrderingTest : public ::testing::Test {
4141
builder.setInsertionPointToStart(&block);
4242
for (int i = 0; i < 4; ++i)
4343
// Ops will be deleted when `block` is destroyed.
44-
v[i] = builder.create<ConstantIntOp>(builder.getUnknownLoc(), i, 32);
44+
v[i] = ConstantIntOp::create(builder, builder.getUnknownLoc(), i, 32);
4545
}
4646

4747
/// Checks that optimal branching on graph has the given cost and

‎mlir/unittests/Dialect/OpenACC/OpenACCOpsTest.cpp

Lines changed: 63 additions & 63 deletions
Large diffs are not rendered by default.

‎mlir/unittests/Dialect/SCF/LoopLikeSCFOpsTest.cpp

Lines changed: 22 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -119,68 +119,68 @@ class SCFLoopLikeTest : public ::testing::Test {
119119

120120
TEST_F(SCFLoopLikeTest, queryUnidimensionalLooplikes) {
121121
OwningOpRef<arith::ConstantIndexOp> lb =
122-
b.create<arith::ConstantIndexOp>(loc, 0);
122+
arith::ConstantIndexOp::create(b, loc, 0);
123123
OwningOpRef<arith::ConstantIndexOp> ub =
124-
b.create<arith::ConstantIndexOp>(loc, 10);
124+
arith::ConstantIndexOp::create(b, loc, 10);
125125
OwningOpRef<arith::ConstantIndexOp> step =
126-
b.create<arith::ConstantIndexOp>(loc, 2);
126+
arith::ConstantIndexOp::create(b, loc, 2);
127127

128128
OwningOpRef<scf::ForOp> forOp =
129-
b.create<scf::ForOp>(loc, lb.get(), ub.get(), step.get());
129+
scf::ForOp::create(b, loc, lb.get(), ub.get(), step.get());
130130
checkUnidimensional(forOp.get());
131131

132-
OwningOpRef<scf::ForallOp> forallOp = b.create<scf::ForallOp>(
133-
loc, ArrayRef<OpFoldResult>(lb->getResult()),
132+
OwningOpRef<scf::ForallOp> forallOp = scf::ForallOp::create(
133+
b, loc, ArrayRef<OpFoldResult>(lb->getResult()),
134134
ArrayRef<OpFoldResult>(ub->getResult()),
135135
ArrayRef<OpFoldResult>(step->getResult()), ValueRange(), std::nullopt);
136136
checkUnidimensional(forallOp.get());
137137

138-
OwningOpRef<scf::ParallelOp> parallelOp = b.create<scf::ParallelOp>(
139-
loc, ValueRange(lb->getResult()), ValueRange(ub->getResult()),
138+
OwningOpRef<scf::ParallelOp> parallelOp = scf::ParallelOp::create(
139+
b, loc, ValueRange(lb->getResult()), ValueRange(ub->getResult()),
140140
ValueRange(step->getResult()), ValueRange());
141141
checkUnidimensional(parallelOp.get());
142142
}
143143

144144
TEST_F(SCFLoopLikeTest, queryMultidimensionalLooplikes) {
145145
OwningOpRef<arith::ConstantIndexOp> lb =
146-
b.create<arith::ConstantIndexOp>(loc, 0);
146+
arith::ConstantIndexOp::create(b, loc, 0);
147147
OwningOpRef<arith::ConstantIndexOp> ub =
148-
b.create<arith::ConstantIndexOp>(loc, 10);
148+
arith::ConstantIndexOp::create(b, loc, 10);
149149
OwningOpRef<arith::ConstantIndexOp> step =
150-
b.create<arith::ConstantIndexOp>(loc, 2);
150+
arith::ConstantIndexOp::create(b, loc, 2);
151151

152-
OwningOpRef<scf::ForallOp> forallOp = b.create<scf::ForallOp>(
153-
loc, ArrayRef<OpFoldResult>({lb->getResult(), lb->getResult()}),
152+
OwningOpRef<scf::ForallOp> forallOp = scf::ForallOp::create(
153+
b, loc, ArrayRef<OpFoldResult>({lb->getResult(), lb->getResult()}),
154154
ArrayRef<OpFoldResult>({ub->getResult(), ub->getResult()}),
155155
ArrayRef<OpFoldResult>({step->getResult(), step->getResult()}),
156156
ValueRange(), std::nullopt);
157157
checkMultidimensional(forallOp.get());
158158

159-
OwningOpRef<scf::ParallelOp> parallelOp = b.create<scf::ParallelOp>(
160-
loc, ValueRange({lb->getResult(), lb->getResult()}),
159+
OwningOpRef<scf::ParallelOp> parallelOp = scf::ParallelOp::create(
160+
b, loc, ValueRange({lb->getResult(), lb->getResult()}),
161161
ValueRange({ub->getResult(), ub->getResult()}),
162162
ValueRange({step->getResult(), step->getResult()}), ValueRange());
163163
checkMultidimensional(parallelOp.get());
164164
}
165165

166166
TEST_F(SCFLoopLikeTest, testForallNormalize) {
167167
OwningOpRef<arith::ConstantIndexOp> lb =
168-
b.create<arith::ConstantIndexOp>(loc, 1);
168+
arith::ConstantIndexOp::create(b, loc, 1);
169169
OwningOpRef<arith::ConstantIndexOp> ub =
170-
b.create<arith::ConstantIndexOp>(loc, 10);
170+
arith::ConstantIndexOp::create(b, loc, 10);
171171
OwningOpRef<arith::ConstantIndexOp> step =
172-
b.create<arith::ConstantIndexOp>(loc, 3);
172+
arith::ConstantIndexOp::create(b, loc, 3);
173173

174-
scf::ForallOp forallOp = b.create<scf::ForallOp>(
175-
loc, ArrayRef<OpFoldResult>({lb->getResult(), lb->getResult()}),
174+
scf::ForallOp forallOp = scf::ForallOp::create(
175+
b, loc, ArrayRef<OpFoldResult>({lb->getResult(), lb->getResult()}),
176176
ArrayRef<OpFoldResult>({ub->getResult(), ub->getResult()}),
177177
ArrayRef<OpFoldResult>({step->getResult(), step->getResult()}),
178178
ValueRange(), std::nullopt);
179179
// Create a user of the induction variable. Bitcast is chosen for simplicity
180180
// since it is unary.
181181
b.setInsertionPointToStart(forallOp.getBody());
182-
b.create<arith::BitcastOp>(UnknownLoc::get(&context), b.getF64Type(),
183-
forallOp.getInductionVar(0));
182+
arith::BitcastOp::create(b, UnknownLoc::get(&context), b.getF64Type(),
183+
forallOp.getInductionVar(0));
184184
IRRewriter rewriter(b);
185185
FailureOr<scf::ForallOp> maybeNormalizedForallOp =
186186
normalizeForallOp(rewriter, forallOp);

‎mlir/unittests/Dialect/SMT/QuantifierTest.cpp

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -26,10 +26,10 @@ TEST(QuantifierTest, ExistsBuilderWithPattern) {
2626
OpBuilder builder(&context);
2727
auto boolTy = BoolType::get(&context);
2828

29-
OwningOpRef<ExistsOp> existsOp = builder.create<ExistsOp>(
30-
loc, TypeRange{boolTy, boolTy},
29+
OwningOpRef<ExistsOp> existsOp = ExistsOp::create(
30+
builder, loc, TypeRange{boolTy, boolTy},
3131
[](OpBuilder &builder, Location loc, ValueRange boundVars) {
32-
return builder.create<AndOp>(loc, boundVars);
32+
return AndOp::create(builder, loc, boundVars);
3333
},
3434
std::nullopt,
3535
[](OpBuilder &builder, Location loc, ValueRange boundVars) {
@@ -57,10 +57,10 @@ TEST(QuantifierTest, ExistsBuilderNoPattern) {
5757
OpBuilder builder(&context);
5858
auto boolTy = BoolType::get(&context);
5959

60-
OwningOpRef<ExistsOp> existsOp = builder.create<ExistsOp>(
61-
loc, TypeRange{boolTy, boolTy},
60+
OwningOpRef<ExistsOp> existsOp = ExistsOp::create(
61+
builder, loc, TypeRange{boolTy, boolTy},
6262
[](OpBuilder &builder, Location loc, ValueRange boundVars) {
63-
return builder.create<AndOp>(loc, boundVars);
63+
return AndOp::create(builder, loc, boundVars);
6464
},
6565
ArrayRef<StringRef>{"a", "b"}, nullptr, /*weight=*/0, /*noPattern=*/true);
6666

@@ -82,10 +82,10 @@ TEST(QuantifierTest, ExistsBuilderDefault) {
8282
OpBuilder builder(&context);
8383
auto boolTy = BoolType::get(&context);
8484

85-
OwningOpRef<ExistsOp> existsOp = builder.create<ExistsOp>(
86-
loc, TypeRange{boolTy, boolTy},
85+
OwningOpRef<ExistsOp> existsOp = ExistsOp::create(
86+
builder, loc, TypeRange{boolTy, boolTy},
8787
[](OpBuilder &builder, Location loc, ValueRange boundVars) {
88-
return builder.create<AndOp>(loc, boundVars);
88+
return AndOp::create(builder, loc, boundVars);
8989
},
9090
ArrayRef<StringRef>{"a", "b"});
9191

@@ -111,10 +111,10 @@ TEST(QuantifierTest, ForallBuilderWithPattern) {
111111
OpBuilder builder(&context);
112112
auto boolTy = BoolType::get(&context);
113113

114-
OwningOpRef<ForallOp> forallOp = builder.create<ForallOp>(
115-
loc, TypeRange{boolTy, boolTy},
114+
OwningOpRef<ForallOp> forallOp = ForallOp::create(
115+
builder, loc, TypeRange{boolTy, boolTy},
116116
[](OpBuilder &builder, Location loc, ValueRange boundVars) {
117-
return builder.create<AndOp>(loc, boundVars);
117+
return AndOp::create(builder, loc, boundVars);
118118
},
119119
ArrayRef<StringRef>{"a", "b"},
120120
[](OpBuilder &builder, Location loc, ValueRange boundVars) {
@@ -142,10 +142,10 @@ TEST(QuantifierTest, ForallBuilderNoPattern) {
142142
OpBuilder builder(&context);
143143
auto boolTy = BoolType::get(&context);
144144

145-
OwningOpRef<ForallOp> forallOp = builder.create<ForallOp>(
146-
loc, TypeRange{boolTy, boolTy},
145+
OwningOpRef<ForallOp> forallOp = ForallOp::create(
146+
builder, loc, TypeRange{boolTy, boolTy},
147147
[](OpBuilder &builder, Location loc, ValueRange boundVars) {
148-
return builder.create<AndOp>(loc, boundVars);
148+
return AndOp::create(builder, loc, boundVars);
149149
},
150150
ArrayRef<StringRef>{"a", "b"}, nullptr, /*weight=*/0, /*noPattern=*/true);
151151

@@ -167,10 +167,10 @@ TEST(QuantifierTest, ForallBuilderDefault) {
167167
OpBuilder builder(&context);
168168
auto boolTy = BoolType::get(&context);
169169

170-
OwningOpRef<ForallOp> forallOp = builder.create<ForallOp>(
171-
loc, TypeRange{boolTy, boolTy},
170+
OwningOpRef<ForallOp> forallOp = ForallOp::create(
171+
builder, loc, TypeRange{boolTy, boolTy},
172172
[](OpBuilder &builder, Location loc, ValueRange boundVars) {
173-
return builder.create<AndOp>(loc, boundVars);
173+
return AndOp::create(builder, loc, boundVars);
174174
},
175175
std::nullopt);
176176

‎mlir/unittests/Dialect/SPIRV/SerializationTest.cpp

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -71,8 +71,8 @@ class SerializationTest : public ::testing::Test {
7171
spirv::GlobalVariableOp addGlobalVar(Type type, llvm::StringRef name) {
7272
OpBuilder builder(module->getRegion());
7373
auto ptrType = spirv::PointerType::get(type, spirv::StorageClass::Uniform);
74-
return builder.create<spirv::GlobalVariableOp>(
75-
UnknownLoc::get(&context), TypeAttr::get(ptrType),
74+
return spirv::GlobalVariableOp::create(
75+
builder, UnknownLoc::get(&context), TypeAttr::get(ptrType),
7676
builder.getStringAttr(name), nullptr);
7777
}
7878

@@ -82,14 +82,14 @@ class SerializationTest : public ::testing::Test {
8282
auto loc = UnknownLoc::get(&context);
8383

8484
if (auto intType = dyn_cast<IntegerType>(type)) {
85-
return builder.create<spirv::ConstantOp>(
86-
loc, type, builder.getIntegerAttr(type, val));
85+
return spirv::ConstantOp::create(builder, loc, type,
86+
builder.getIntegerAttr(type, val));
8787
}
8888
if (auto vectorType = dyn_cast<VectorType>(type)) {
8989
Type elemType = vectorType.getElementType();
9090
if (auto intType = dyn_cast<IntegerType>(elemType)) {
91-
return builder.create<spirv::ConstantOp>(
92-
loc, type,
91+
return spirv::ConstantOp::create(
92+
builder, loc, type,
9393
DenseElementsAttr::get(vectorType,
9494
IntegerAttr::get(elemType, val).getValue()));
9595
}

‎mlir/unittests/IR/IRMapping.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -26,10 +26,10 @@ TEST(IRMapping, TypedValue) {
2626
Block block;
2727
builder.setInsertionPointToEnd(&block);
2828

29-
Value i64Val = builder.create<test::TestOpConstant>(
30-
loc, builder.getI64Type(), builder.getI64IntegerAttr(0));
31-
Value f64Val = builder.create<test::TestOpConstant>(
32-
loc, builder.getF64Type(), builder.getF64FloatAttr(0.0));
29+
Value i64Val = test::TestOpConstant::create(
30+
builder, loc, builder.getI64Type(), builder.getI64IntegerAttr(0));
31+
Value f64Val = test::TestOpConstant::create(
32+
builder, loc, builder.getF64Type(), builder.getF64FloatAttr(0.0));
3333

3434
IRMapping mapping;
3535
mapping.map(i64Val, f64Val);

‎mlir/unittests/IR/InterfaceAttachmentTest.cpp

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -303,7 +303,7 @@ TEST(InterfaceAttachment, Operation) {
303303

304304
// Initially, the operation doesn't have the interface.
305305
OwningOpRef<ModuleOp> moduleOp =
306-
builder.create<ModuleOp>(UnknownLoc::get(&context));
306+
ModuleOp::create(builder, UnknownLoc::get(&context));
307307
ASSERT_FALSE(isa<TestExternalOpInterface>(moduleOp->getOperation()));
308308

309309
// We can attach an external interface and now the operaiton has it.
@@ -317,8 +317,8 @@ TEST(InterfaceAttachment, Operation) {
317317

318318
// Default implementation can be overridden.
319319
OwningOpRef<UnrealizedConversionCastOp> castOp =
320-
builder.create<UnrealizedConversionCastOp>(UnknownLoc::get(&context),
321-
TypeRange(), ValueRange());
320+
UnrealizedConversionCastOp::create(builder, UnknownLoc::get(&context),
321+
TypeRange(), ValueRange());
322322
ASSERT_FALSE(isa<TestExternalOpInterface>(castOp->getOperation()));
323323
UnrealizedConversionCastOp::attachInterface<TestExternalOpOverridingModel>(
324324
context);
@@ -368,11 +368,11 @@ TEST(InterfaceAttachment, OperationDelayedContextConstruct) {
368368
OwningOpRef<ModuleOp> module = ModuleOp::create(UnknownLoc::get(&context));
369369
OpBuilder builder(module->getBody(), module->getBody()->begin());
370370
auto opJ =
371-
builder.create<test::OpJ>(builder.getUnknownLoc(), builder.getI32Type());
371+
test::OpJ::create(builder, builder.getUnknownLoc(), builder.getI32Type());
372372
auto opH =
373-
builder.create<test::OpH>(builder.getUnknownLoc(), opJ.getResult());
373+
test::OpH::create(builder, builder.getUnknownLoc(), opJ.getResult());
374374
auto opI =
375-
builder.create<test::OpI>(builder.getUnknownLoc(), opJ.getResult());
375+
test::OpI::create(builder, builder.getUnknownLoc(), opJ.getResult());
376376

377377
EXPECT_TRUE(isa<TestExternalOpInterface>(module->getOperation()));
378378
EXPECT_TRUE(isa<TestExternalOpInterface>(opJ.getOperation()));
@@ -399,11 +399,11 @@ TEST(InterfaceAttachment, OperationDelayedContextAppend) {
399399
OwningOpRef<ModuleOp> module = ModuleOp::create(UnknownLoc::get(&context));
400400
OpBuilder builder(module->getBody(), module->getBody()->begin());
401401
auto opJ =
402-
builder.create<test::OpJ>(builder.getUnknownLoc(), builder.getI32Type());
402+
test::OpJ::create(builder, builder.getUnknownLoc(), builder.getI32Type());
403403
auto opH =
404-
builder.create<test::OpH>(builder.getUnknownLoc(), opJ.getResult());
404+
test::OpH::create(builder, builder.getUnknownLoc(), opJ.getResult());
405405
auto opI =
406-
builder.create<test::OpI>(builder.getUnknownLoc(), opJ.getResult());
406+
test::OpI::create(builder, builder.getUnknownLoc(), opJ.getResult());
407407

408408
EXPECT_FALSE(isa<TestExternalOpInterface>(module->getOperation()));
409409
EXPECT_FALSE(isa<TestExternalOpInterface>(opJ.getOperation()));

‎mlir/unittests/IR/InterfaceTest.cpp

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -27,12 +27,12 @@ TEST(InterfaceTest, OpInterfaceDenseMapKey) {
2727

2828
OwningOpRef<ModuleOp> module = ModuleOp::create(UnknownLoc::get(&context));
2929
OpBuilder builder(module->getBody(), module->getBody()->begin());
30-
auto op1 = builder.create<test::SideEffectOp>(builder.getUnknownLoc(),
31-
builder.getI32Type());
32-
auto op2 = builder.create<test::SideEffectOp>(builder.getUnknownLoc(),
33-
builder.getI32Type());
34-
auto op3 = builder.create<test::SideEffectOp>(builder.getUnknownLoc(),
35-
builder.getI32Type());
30+
auto op1 = test::SideEffectOp::create(builder, builder.getUnknownLoc(),
31+
builder.getI32Type());
32+
auto op2 = test::SideEffectOp::create(builder, builder.getUnknownLoc(),
33+
builder.getI32Type());
34+
auto op3 = test::SideEffectOp::create(builder, builder.getUnknownLoc(),
35+
builder.getI32Type());
3636
DenseSet<MemoryEffectOpInterface> opSet;
3737
opSet.insert(op1);
3838
opSet.insert(op2);
@@ -64,8 +64,8 @@ TEST(InterfaceTest, TestCustomClassOf) {
6464
context.loadDialect<test::TestDialect>();
6565

6666
OpBuilder builder(&context);
67-
auto op = builder.create<TestOpOptionallyImplementingInterface>(
68-
builder.getUnknownLoc(), /*implementsInterface=*/true);
67+
auto op = TestOpOptionallyImplementingInterface::create(
68+
builder, builder.getUnknownLoc(), /*implementsInterface=*/true);
6969
EXPECT_TRUE(isa<TestOptionallyImplementedOpInterface>(*op));
7070
op.setImplementsInterface(false);
7171
EXPECT_FALSE(isa<TestOptionallyImplementedOpInterface>(*op));

‎mlir/unittests/IR/OperationSupportTest.cpp

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -302,8 +302,8 @@ TEST(OperandStorageTest, PopulateDefaultAttrs) {
302302
auto req1 = b.getI32IntegerAttr(10);
303303
auto req2 = b.getI32IntegerAttr(60);
304304
// Verify default attributes populated post op creation.
305-
Operation *op = b.create<test::OpAttrMatch1>(b.getUnknownLoc(), req1, nullptr,
306-
nullptr, req2);
305+
Operation *op = test::OpAttrMatch1::create(b, b.getUnknownLoc(), req1,
306+
nullptr, nullptr, req2);
307307
auto opt = op->getInherentAttr("default_valued_attr");
308308
EXPECT_NE(opt, nullptr) << *op;
309309

@@ -343,11 +343,11 @@ TEST(OperationEquivalenceTest, HashWorksWithFlags) {
343343

344344
// Check ignore properties.
345345
auto req1 = b.getI32IntegerAttr(10);
346-
Operation *opWithProperty1 = b.create<test::OpAttrMatch1>(
347-
b.getUnknownLoc(), req1, nullptr, nullptr, req1);
346+
Operation *opWithProperty1 = test::OpAttrMatch1::create(
347+
b, b.getUnknownLoc(), req1, nullptr, nullptr, req1);
348348
auto req2 = b.getI32IntegerAttr(60);
349-
Operation *opWithProperty2 = b.create<test::OpAttrMatch1>(
350-
b.getUnknownLoc(), req2, nullptr, nullptr, req2);
349+
Operation *opWithProperty2 = test::OpAttrMatch1::create(
350+
b, b.getUnknownLoc(), req2, nullptr, nullptr, req2);
351351
EXPECT_EQ(getHash(opWithProperty1, OperationEquivalence::IgnoreProperties),
352352
getHash(opWithProperty2, OperationEquivalence::IgnoreProperties));
353353
EXPECT_NE(getHash(opWithProperty1, OperationEquivalence::None),

0 commit comments

Comments
 (0)