Update more `parseSourceString()` call sites.

[csigg]

Summary

Change to non-deprecated function template (see D121075).

[ftynse]

The patch seems to include irrelevant bazel changes.

[csigg]

Rebase.

[rriddle]

mlir/unittests/Transforms/Canonicalizer.cpp

78

Can we drop the mlir:: here?

[kevcadieux]

Hello @csigg, there seems to be another use of the deprecated parseSourceString function in mlir/lib/CAPI/IR/IR.cpp that is causing a deprecated error in our builds. Would you mind please updating that use as well? Thanks!

[csigg]

Fix mlir/lib/CAPI/IR/IR.cpp as well.

[csigg]

In D121102#3366204, @kevcadieux wrote:

Hello @csigg, there seems to be another use of the deprecated parseSourceString function in mlir/lib/CAPI/IR/IR.cpp that is causing a deprecated error in our builds. Would you mind please updating that use as well? Thanks!

Done.

Does that mean that we are not supposed to mark things deprecated?
Or would it make sense to only treat deprecations as warnings in your build?

[kevcadieux]

In D121102#3366800, @csigg wrote:

In D121102#3366204, @kevcadieux wrote:

Hello @csigg, there seems to be another use of the deprecated parseSourceString function in mlir/lib/CAPI/IR/IR.cpp that is causing a deprecated error in our builds. Would you mind please updating that use as well? Thanks!

Done.

Does that mean that we are not supposed to mark things deprecated?
Or would it make sense to only treat deprecations as warnings in your build?

Thanks for fixing the use. I was about to submit a change myself but saw that you had a similar one and decided to ask.
In this particular instance I thought it was better to fix the call site rather than ignore the warning / error. I can't speak to the preferences of the entire LLVM community, however.

mlir/lib/CAPI/IR/IR.cpp

 //===----------------------------------------------------------------------===//
 
 MlirModule mlirModuleCreateEmpty(MlirLocation location) {
   return wrap(ModuleOp::create(unwrap(location)));
 }
 
 MlirModule mlirModuleCreateParse(MlirContext context, MlirStringRef module) {
   OwningOpRef<ModuleOp> owning =
-      parseSourceString(unwrap(module), unwrap(context));
+      parseSourceString<ModuleOp>(unwrap(module), unwrap(context));
   if (!owning)
     return MlirModule{nullptr};
   return MlirModule{owning.release().getOperation()};
 }
 
 MlirContext mlirModuleGetContext(MlirModule module) {
   return wrap(unwrap(module).getContext());
 }

mlir/unittests/ExecutionEngine/Invoke.cpp

func @foo(%arg0 : i32) -> i32 attributes { llvm.emit_c_interface } {
     %res = arith.addi %arg0, %arg0 : i32
     return %res : i32
   }
   )mlir";
   DialectRegistry registry;
   registerAllDialects(registry);
   registerLLVMDialectTranslation(registry);
   MLIRContext context(registry);
-  OwningOpRef<ModuleOp> module = parseSourceString(moduleStr, &context);
+  OwningOpRef<ModuleOp> module =
+      parseSourceString<ModuleOp>(moduleStr, &context);
   ASSERT_TRUE(!!module);
   ASSERT_TRUE(succeeded(lowerToLLVMDialect(*module)));
   auto jitOrError = ExecutionEngine::create(*module);
   ASSERT_TRUE(!!jitOrError);
   std::unique_ptr<ExecutionEngine> jit = std::move(jitOrError.get());
   // The result of the function must be passed as output argument.
   int result = 0;
   llvm::Error error =
       jit->invoke("foo", 42, ExecutionEngine::Result<int>(result));
   ASSERT_TRUE(!error);
   ASSERT_EQ(result, 42 + 42);
 }
 
 TEST(MLIRExecutionEngine, SubtractFloat) {
   std::string moduleStr = R"mlir(
   func @foo(%arg0 : f32, %arg1 : f32) -> f32 attributes { llvm.emit_c_interface } {
     %res = arith.subf %arg0, %arg1 : f32
     return %res : f32
   }
   )mlir";
   DialectRegistry registry;
   registerAllDialects(registry);
   registerLLVMDialectTranslation(registry);
   MLIRContext context(registry);
-  OwningOpRef<ModuleOp> module = parseSourceString(moduleStr, &context);
+  OwningOpRef<ModuleOp> module =
+      parseSourceString<ModuleOp>(moduleStr, &context);
   ASSERT_TRUE(!!module);
   ASSERT_TRUE(succeeded(lowerToLLVMDialect(*module)));
   auto jitOrError = ExecutionEngine::create(*module);
   ASSERT_TRUE(!!jitOrError);
   std::unique_ptr<ExecutionEngine> jit = std::move(jitOrError.get());
   // The result of the function must be passed as output argument.
   float result = -1;
   llvm::Error error =
func @zero_ranked(%arg0 : memref<f32>) attributes { llvm.emit_c_interface } {
     memref.store %cst42, %arg0[] : memref<f32>
     return
   }
   )mlir";
   DialectRegistry registry;
   registerAllDialects(registry);
   registerLLVMDialectTranslation(registry);
   MLIRContext context(registry);
-  auto module = parseSourceString(moduleStr, &context);
+  auto module = parseSourceString<ModuleOp>(moduleStr, &context);
   ASSERT_TRUE(!!module);
   ASSERT_TRUE(succeeded(lowerToLLVMDialect(*module)));
   auto jitOrError = ExecutionEngine::create(*module);
   ASSERT_TRUE(!!jitOrError);
   auto jit = std::move(jitOrError.get());
 
   llvm::Error error = jit->invoke("zero_ranked", &*a);
   ASSERT_TRUE(!error);
func @one_ranked(%arg0 : memref<?xf32>) attributes { llvm.emit_c_interface } {
     memref.store %cst42, %arg0[%cst5] : memref<?xf32>
     return
   }
   )mlir";
   DialectRegistry registry;
   registerAllDialects(registry);
   registerLLVMDialectTranslation(registry);
   MLIRContext context(registry);
-  auto module = parseSourceString(moduleStr, &context);
+  auto module = parseSourceString<ModuleOp>(moduleStr, &context);
   ASSERT_TRUE(!!module);
   ASSERT_TRUE(succeeded(lowerToLLVMDialect(*module)));
   auto jitOrError = ExecutionEngine::create(*module);
   ASSERT_TRUE(!!jitOrError);
   auto jit = std::move(jitOrError.get());
 
   llvm::Error error = jit->invoke("one_ranked", &*a);
   ASSERT_TRUE(!error);
func @rank2_memref(%arg0 : memref<?x?xf32>, %arg1 : memref<?x?xf32>) attributes { llvm.emit_c_interface } {
     memref.store %cst42, %arg1[%x, %y] : memref<?x?xf32>
     return
   }
   )mlir";
   DialectRegistry registry;
   registerAllDialects(registry);
   registerLLVMDialectTranslation(registry);
   MLIRContext context(registry);
-  OwningOpRef<ModuleOp> module = parseSourceString(moduleStr, &context);
+  OwningOpRef<ModuleOp> module =
+      parseSourceString<ModuleOp>(moduleStr, &context);
   ASSERT_TRUE(!!module);
   ASSERT_TRUE(succeeded(lowerToLLVMDialect(*module)));
   auto jitOrError = ExecutionEngine::create(*module);
   ASSERT_TRUE(!!jitOrError);
   std::unique_ptr<ExecutionEngine> jit = std::move(jitOrError.get());
 
   llvm::Error error = jit->invoke("rank2_memref", &*a, &*a);
   ASSERT_TRUE(!error);
func @caller_for_callback(%arg0: memref<?x?xf32>, %coefficient: i32) attributes { llvm.emit_c_interface } {
     call @callback(%arg0, %coefficient) : (memref<?x?xf32>, i32) -> ()
     return
   }
   )mlir";
   DialectRegistry registry;
   registerAllDialects(registry);
   registerLLVMDialectTranslation(registry);
   MLIRContext context(registry);
-  auto module = parseSourceString(moduleStr, &context);
+  auto module = parseSourceString<ModuleOp>(moduleStr, &context);
   ASSERT_TRUE(!!module);
   ASSERT_TRUE(succeeded(lowerToLLVMDialect(*module)));
   auto jitOrError = ExecutionEngine::create(*module);
   ASSERT_TRUE(!!jitOrError);
   auto jit = std::move(jitOrError.get());
   // Define any extra symbols so they're available at runtime.
   jit->registerSymbols([&](llvm::orc::MangleAndInterner interner) {
     llvm::orc::SymbolMap symbolMap;

mlir/unittests/Interfaces/ControlFlowInterfacesTest.cpp

"cftest.mutually_exclusive_regions_op"() (
       {"cftest.dummy_op"() : () -> ()}   // op2
   ) : () -> ()
   )MLIR";
 
   DialectRegistry registry;
   registry.insert<CFTestDialect>();
   MLIRContext ctx(registry);
 
-  OwningOpRef<ModuleOp> module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString<ModuleOp>(ir, &ctx);
   Operation *testOp = &module->getBody()->getOperations().front();
   Operation *op1 = &testOp->getRegion(0).front().front();
   Operation *op2 = &testOp->getRegion(1).front().front();
 
   EXPECT_TRUE(insideMutuallyExclusiveRegions(op1, op2));
   EXPECT_TRUE(insideMutuallyExclusiveRegions(op2, op1));
 }
 
 TEST(RegionBranchOpInterface, NotMutuallyExclusiveOps) {
   const char *ir = R"MLIR(
 "cftest.sequential_regions_op"() (
       {"cftest.dummy_op"() : () -> ()},  // op1
       {"cftest.dummy_op"() : () -> ()}   // op2
   ) : () -> ()
   )MLIR";
 
   DialectRegistry registry;
   registry.insert<CFTestDialect>();
   MLIRContext ctx(registry);
 
-  OwningOpRef<ModuleOp> module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString<ModuleOp>(ir, &ctx);
   Operation *testOp = &module->getBody()->getOperations().front();
   Operation *op1 = &testOp->getRegion(0).front().front();
   Operation *op2 = &testOp->getRegion(1).front().front();
 
   EXPECT_FALSE(insideMutuallyExclusiveRegions(op1, op2));
   EXPECT_FALSE(insideMutuallyExclusiveRegions(op2, op1));
 }
 
"cftest.mutually_exclusive_regions_op"() (
       {"cftest.dummy_op"() : () -> ()}           // op2
   ) : () -> ()
   )MLIR";
 
   DialectRegistry registry;
   registry.insert<CFTestDialect>();
   MLIRContext ctx(registry);
 
-  OwningOpRef<ModuleOp> module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString<ModuleOp>(ir, &ctx);
   Operation *testOp = &module->getBody()->getOperations().front();
   Operation *op1 =
       &testOp->getRegion(0).front().front().getRegion(0).front().front();
   Operation *op2 = &testOp->getRegion(1).front().front();
   Operation *op3 =
       &testOp->getRegion(0).front().front().getRegion(1).front().front();
 
   EXPECT_TRUE(insideMutuallyExclusiveRegions(op1, op2));
   EXPECT_TRUE(insideMutuallyExclusiveRegions(op3, op2));
   EXPECT_FALSE(insideMutuallyExclusiveRegions(op1, op3));
 }

mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp

TEST(DataLayout, FallbackDefault) {
   const char *ir = R"MLIR(
 module {}
   )MLIR";
 
   DialectRegistry registry;
   registry.insert<DLTIDialect, DLTestDialect>();
   MLIRContext ctx(registry);
 
-  OwningOpRef<ModuleOp> module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString<ModuleOp>(ir, &ctx);
   DataLayout layout(module.get());
   EXPECT_EQ(layout.getTypeSize(IntegerType::get(&ctx, 42)), 6u);
   EXPECT_EQ(layout.getTypeSize(Float16Type::get(&ctx)), 2u);
   EXPECT_EQ(layout.getTypeSizeInBits(IntegerType::get(&ctx, 42)), 42u);
   EXPECT_EQ(layout.getTypeSizeInBits(Float16Type::get(&ctx)), 16u);
   EXPECT_EQ(layout.getTypeABIAlignment(IntegerType::get(&ctx, 42)), 8u);
   EXPECT_EQ(layout.getTypeABIAlignment(Float16Type::get(&ctx)), 2u);
   EXPECT_EQ(layout.getTypePreferredAlignment(IntegerType::get(&ctx, 42)), 8u);
   EXPECT_EQ(layout.getTypePreferredAlignment(Float16Type::get(&ctx)), 2u);
 }
 
 TEST(DataLayout, NullSpec) {
   const char *ir = R"MLIR(
 "dltest.op_with_layout"() : () -> ()
   )MLIR";
 
   DialectRegistry registry;
   registry.insert<DLTIDialect, DLTestDialect>();
   MLIRContext ctx(registry);
 
-  OwningOpRef<ModuleOp> module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString<ModuleOp>(ir, &ctx);
   auto op =
       cast<DataLayoutOpInterface>(module->getBody()->getOperations().front());
   DataLayout layout(op);
   EXPECT_EQ(layout.getTypeSize(IntegerType::get(&ctx, 42)), 42u);
   EXPECT_EQ(layout.getTypeSize(Float16Type::get(&ctx)), 16u);
   EXPECT_EQ(layout.getTypeSizeInBits(IntegerType::get(&ctx, 42)), 8u * 42u);
   EXPECT_EQ(layout.getTypeSizeInBits(Float16Type::get(&ctx)), 8u * 16u);
   EXPECT_EQ(layout.getTypeABIAlignment(IntegerType::get(&ctx, 42)), 64u);
   EXPECT_EQ(layout.getTypeABIAlignment(Float16Type::get(&ctx)), 16u);
   EXPECT_EQ(layout.getTypePreferredAlignment(IntegerType::get(&ctx, 42)), 128u);
   EXPECT_EQ(layout.getTypePreferredAlignment(Float16Type::get(&ctx)), 32u);
 }
 
 TEST(DataLayout, EmptySpec) {
   const char *ir = R"MLIR(
 "dltest.op_with_layout"() { dltest.layout = #dltest.spec< > } : () -> ()
   )MLIR";
 
   DialectRegistry registry;
   registry.insert<DLTIDialect, DLTestDialect>();
   MLIRContext ctx(registry);
 
-  OwningOpRef<ModuleOp> module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString<ModuleOp>(ir, &ctx);
   auto op =
       cast<DataLayoutOpInterface>(module->getBody()->getOperations().front());
   DataLayout layout(op);
   EXPECT_EQ(layout.getTypeSize(IntegerType::get(&ctx, 42)), 42u);
   EXPECT_EQ(layout.getTypeSize(Float16Type::get(&ctx)), 16u);
   EXPECT_EQ(layout.getTypeSizeInBits(IntegerType::get(&ctx, 42)), 8u * 42u);
   EXPECT_EQ(layout.getTypeSizeInBits(Float16Type::get(&ctx)), 8u * 16u);
   EXPECT_EQ(layout.getTypeABIAlignment(IntegerType::get(&ctx, 42)), 64u);
"dltest.op_with_layout"() { dltest.layout = #dltest.spec<
   #dlti.dl_entry<i16, 6>
 > } : () -> ()
   )MLIR";
 
   DialectRegistry registry;
   registry.insert<DLTIDialect, DLTestDialect>();
   MLIRContext ctx(registry);
 
-  OwningOpRef<ModuleOp> module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString<ModuleOp>(ir, &ctx);
   auto op =
       cast<DataLayoutOpInterface>(module->getBody()->getOperations().front());
   DataLayout layout(op);
   EXPECT_EQ(layout.getTypeSize(IntegerType::get(&ctx, 42)), 5u);
   EXPECT_EQ(layout.getTypeSize(Float16Type::get(&ctx)), 6u);
   EXPECT_EQ(layout.getTypeSizeInBits(IntegerType::get(&ctx, 42)), 40u);
   EXPECT_EQ(layout.getTypeSizeInBits(Float16Type::get(&ctx)), 48u);
   EXPECT_EQ(layout.getTypeABIAlignment(IntegerType::get(&ctx, 42)), 8u);
TEST(DataLayout, Caching) {
   const char *ir = R"MLIR(
 "dltest.op_with_layout"() { dltest.layout = #dltest.spec<> } : () -> ()
   )MLIR";
 
   DialectRegistry registry;
   registry.insert<DLTIDialect, DLTestDialect>();
   MLIRContext ctx(registry);
 
-  OwningOpRef<ModuleOp> module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString<ModuleOp>(ir, &ctx);
   auto op =
       cast<DataLayoutOpInterface>(module->getBody()->getOperations().front());
   DataLayout layout(op);
 
   unsigned sum = 0;
   sum += layout.getTypeSize(SingleQueryType::get(&ctx));
   // The second call should hit the cache. If it does not, the function in
   // SingleQueryType will be called and will abort the process.
"dltest.op_with_layout"() { dltest.layout = #dltest.spec<
   #dlti.dl_entry<i16, 6>
 > } : () -> ()
   )MLIR";
 
   DialectRegistry registry;
   registry.insert<DLTIDialect, DLTestDialect>();
   MLIRContext ctx(registry);
 
-  OwningOpRef<ModuleOp> module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString<ModuleOp>(ir, &ctx);
   auto op =
       cast<DataLayoutOpInterface>(module->getBody()->getOperations().front());
   DataLayout layout(op);
 
   // Normal query is fine.
   EXPECT_EQ(layout.getTypeSize(Float16Type::get(&ctx)), 6u);
 
   // Replace the data layout spec with a new, empty spec.
TEST(DataLayout, UnimplementedTypeInterface) {
   const char *ir = R"MLIR(
 "dltest.op_with_layout"() { dltest.layout = #dltest.spec<> } : () -> ()
   )MLIR";
 
   DialectRegistry registry;
   registry.insert<DLTIDialect, DLTestDialect>();
   MLIRContext ctx(registry);
 
-  OwningOpRef<ModuleOp> module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString<ModuleOp>(ir, &ctx);
   auto op =
       cast<DataLayoutOpInterface>(module->getBody()->getOperations().front());
   DataLayout layout(op);
 
   ASSERT_DEATH(layout.getTypeSize(TypeNoLayout::get(&ctx)),
                "neither the scoping op nor the type class provide data layout "
                "information");
 }
 
 TEST(DataLayout, SevenBitByte) {
   const char *ir = R"MLIR(
 "dltest.op_with_7bit_byte"() { dltest.layout = #dltest.spec<> } : () -> ()
   )MLIR";
 
   DialectRegistry registry;
   registry.insert<DLTIDialect, DLTestDialect>();
   MLIRContext ctx(registry);
 
-  OwningOpRef<ModuleOp> module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString<ModuleOp>(ir, &ctx);
   auto op =
       cast<DataLayoutOpInterface>(module->getBody()->getOperations().front());
   DataLayout layout(op);
 
   EXPECT_EQ(layout.getTypeSizeInBits(IntegerType::get(&ctx, 42)), 42u);
   EXPECT_EQ(layout.getTypeSizeInBits(IntegerType::get(&ctx, 32)), 32u);
   EXPECT_EQ(layout.getTypeSize(IntegerType::get(&ctx, 42)), 6u);
   EXPECT_EQ(layout.getTypeSize(IntegerType::get(&ctx, 32)), 5u);
 }

mlir/unittests/Interfaces/InferTypeOpInterfaceTest.cpp

const char *ir = R"MLIR(
         %0 = arith.constant dense<[10]> : tensor<1xi64>
         %1 = arith.addi %arg, %0 : tensor<1xi64>
         return
       }
     )MLIR";
 
     registry.insert<func::FuncDialect, arith::ArithmeticDialect>();
     ctx.appendDialectRegistry(registry);
-    module = parseSourceString(ir, &ctx);
+    module = parseSourceString<ModuleOp>(ir, &ctx);
     mapFn = cast<FuncOp>(module->front());
   }
 
   // Create ValueShapeRange on the arith.addi operation.
   ValueShapeRange addiRange() {
     auto &fnBody = mapFn.body();
     return std::next(fnBody.front().begin())->getOperands();
   }

mlir/unittests/Transforms/Canonicalizer.cpp

TEST(CanonicalizerTest, TestDisablePatterns) {
   mgr.addPass(
       createCanonicalizerPass(GreedyRewriteConfig(), {"DisabledPattern"}));
 
   const char *const code = R"mlir(
     %0:2 = "test.foo"() {sym_name = "A"} : () -> (i32, i32)
     %1 = "test.foo"() {sym_name = "B"} : () -> (f32)
   )mlir";
 
-  OwningOpRef<ModuleOp> module = mlir::parseSourceString(code, &context);
+  OwningOpRef<ModuleOp> module = parseSourceString<ModuleOp>(code, &context);
   ASSERT_TRUE(succeeded(mgr.run(*module)));
 
   EXPECT_TRUE(module->lookupSymbol("B"));
   EXPECT_FALSE(module->lookupSymbol("A"));
 }
 
 } // end anonymous namespace