[MLIR] Change call sites from deprecated `parseSourceFile()` to `parseSourceFile<ModuleOp>()`.

[csigg]

Summary

Mark parseSourceFile() deprecated. The functions will be removed two weeks after landing this change.

[rriddle]

Ohoh, sweet!

mlir/examples/toy/Ch2/toyc.cpp

if (std::error_code ec = fileOrErr.getError()) {
     llvm::errs() << "Could not open input file: " << ec.message() << "\n";
     return -1;
   }
 
   // Parse the input mlir.
   llvm::SourceMgr sourceMgr;
   sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
   mlir::OwningOpRef<mlir::ModuleOp> module =
-      mlir::parseSourceFile(sourceMgr, &context);
+      mlir::parseSourceFile<mlir::ModuleOp>(sourceMgr, &context);
   if (!module) {
     llvm::errs() << "Error can't load file " << inputFilename << "\n";
     return 3;
   }
 
   module->dump();
   return 0;
 }

mlir/examples/toy/Ch3/toyc.cpp

llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
       llvm::MemoryBuffer::getFileOrSTDIN(inputFilename);
   if (std::error_code ec = fileOrErr.getError()) {
     llvm::errs() << "Could not open input file: " << ec.message() << "\n";
     return -1;
   }
 
   // Parse the input mlir.
   sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
-  module = mlir::parseSourceFile(sourceMgr, &context);
+  module = mlir::parseSourceFile<mlir::ModuleOp>(sourceMgr, &context);
   if (!module) {
     llvm::errs() << "Error can't load file " << inputFilename << "\n";
     return 3;
   }
   return 0;
 }
 
 int dumpMLIR() {

mlir/examples/toy/Ch4/toyc.cpp

llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
       llvm::MemoryBuffer::getFileOrSTDIN(inputFilename);
   if (std::error_code ec = fileOrErr.getError()) {
     llvm::errs() << "Could not open input file: " << ec.message() << "\n";
     return -1;
   }
 
   // Parse the input mlir.
   sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
-  module = mlir::parseSourceFile(sourceMgr, &context);
+  module = mlir::parseSourceFile<mlir::ModuleOp>(sourceMgr, &context);
   if (!module) {
     llvm::errs() << "Error can't load file " << inputFilename << "\n";
     return 3;
   }
   return 0;
 }
 
 int dumpMLIR() {

mlir/examples/toy/Ch5/toyc.cpp

llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
       llvm::MemoryBuffer::getFileOrSTDIN(inputFilename);
   if (std::error_code ec = fileOrErr.getError()) {
     llvm::errs() << "Could not open input file: " << ec.message() << "\n";
     return -1;
   }
 
   // Parse the input mlir.
   sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
-  module = mlir::parseSourceFile(sourceMgr, &context);
+  module = mlir::parseSourceFile<mlir::ModuleOp>(sourceMgr, &context);
   if (!module) {
     llvm::errs() << "Error can't load file " << inputFilename << "\n";
     return 3;
   }
   return 0;
 }
 
 int dumpMLIR() {

mlir/examples/toy/Ch6/toyc.cpp

int loadMLIR(mlir::MLIRContext &context,
   if (std::error_code ec = fileOrErr.getError()) {
     llvm::errs() << "Could not open input file: " << ec.message() << "\n";
     return -1;
   }
 
   // Parse the input mlir.
   llvm::SourceMgr sourceMgr;
   sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
-  module = mlir::parseSourceFile(sourceMgr, &context);
+  module = mlir::parseSourceFile<mlir::ModuleOp>(sourceMgr, &context);
   if (!module) {
     llvm::errs() << "Error can't load file " << inputFilename << "\n";
     return 3;
   }
   return 0;
 }
 
 int loadAndProcessMLIR(mlir::MLIRContext &context,

mlir/examples/toy/Ch7/toyc.cpp

int loadMLIR(mlir::MLIRContext &context,
   if (std::error_code ec = fileOrErr.getError()) {
     llvm::errs() << "Could not open input file: " << ec.message() << "\n";
     return -1;
   }
 
   // Parse the input mlir.
   llvm::SourceMgr sourceMgr;
   sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
-  module = mlir::parseSourceFile(sourceMgr, &context);
+  module = mlir::parseSourceFile<mlir::ModuleOp>(sourceMgr, &context);
   if (!module) {
     llvm::errs() << "Error can't load file " << inputFilename << "\n";
     return 3;
   }
   return 0;
 }
 
 int loadAndProcessMLIR(mlir::MLIRContext &context,

mlir/include/mlir/Parser.h

inline OwningOpRef<ContainerOpT> parseSourceString(llvm::StringRef sourceStr,
   if (failed(parseSourceString(sourceStr, &block, context, &sourceFileLoc)))
     return OwningOpRef<ContainerOpT>();
   return detail::constructContainerOpForParserIfNecessary<ContainerOpT>(
       &block, context, sourceFileLoc);
 }
 
 /// TODO: These methods are deprecated in favor of the above template versions.
 /// They should be removed when usages have been updated.
-inline OwningOpRef<ModuleOp> parseSourceFile(const llvm::SourceMgr &sourceMgr,
-                                             MLIRContext *context) {
+[[deprecated("use parseSourceFile<ModuleOp>")]] inline OwningOpRef<ModuleOp>
+parseSourceFile(const llvm::SourceMgr &sourceMgr, MLIRContext *context) {
   return parseSourceFile<ModuleOp>(sourceMgr, context);
 }
-inline OwningOpRef<ModuleOp> parseSourceFile(llvm::StringRef filename,
-                                             MLIRContext *context) {
+[[deprecated("use parseSourceFile<ModuleOp>")]] inline OwningOpRef<ModuleOp>
+parseSourceFile(llvm::StringRef filename, MLIRContext *context) {
   return parseSourceFile<ModuleOp>(filename, context);
 }
-inline OwningOpRef<ModuleOp> parseSourceFile(llvm::StringRef filename,
-                                             llvm::SourceMgr &sourceMgr,
-                                             MLIRContext *context) {
+[[deprecated("use parseSourceFile<ModuleOp>")]] inline OwningOpRef<ModuleOp>
+parseSourceFile(llvm::StringRef filename, llvm::SourceMgr &sourceMgr,
   return parseSourceFile<ModuleOp>(filename, sourceMgr, context);
 }
-inline OwningOpRef<ModuleOp> parseSourceString(llvm::StringRef moduleStr,
-                                               MLIRContext *context) {
+[[deprecated("use parseSourceFile<ModuleOp>")]] inline OwningOpRef<ModuleOp>
+parseSourceString(llvm::StringRef moduleStr, MLIRContext *context) {
   return parseSourceString<ModuleOp>(moduleStr, context);
 }
 
 /// This parses a single MLIR attribute to an MLIR context if it was valid.  If
 /// not, an error message is emitted through a new SourceMgrDiagnosticHandler
 /// constructed from a new SourceMgr with a single a MemoryBuffer wrapping
 /// `attrStr`. If the passed `attrStr` has additional tokens that were not part
 /// of the type, an error is emitted.

mlir/lib/ExecutionEngine/JitRunner.cpp

static OwningOpRef<ModuleOp> parseMLIRInput(StringRef inputFilename,
   auto file = openInputFile(inputFilename, &errorMessage);
   if (!file) {
     llvm::errs() << errorMessage << "\n";
     return nullptr;
   }
 
   llvm::SourceMgr sourceMgr;
   sourceMgr.AddNewSourceBuffer(std::move(file), SMLoc());
-  return OwningOpRef<ModuleOp>(parseSourceFile(sourceMgr, context));
+  return parseSourceFile<ModuleOp>(sourceMgr, context);
 }
 
 static inline Error makeStringError(const Twine &message) {
   return llvm::make_error<llvm::StringError>(message.str(),
                                              llvm::inconvertibleErrorCode());
 }
 
 static Optional<unsigned> getCommandLineOptLevel(Options &options) {

mlir/lib/Support/MlirOptMain.cpp

static LogicalResult performActions(raw_ostream &os, bool verifyDiagnostics,
 
   // Disable multi-threading when parsing the input file. This removes the
   // unnecessary/costly context synchronization when parsing.
   bool wasThreadingEnabled = context->isMultithreadingEnabled();
   context->disableMultithreading();
 
   // Parse the input file and reset the context threading state.
   TimingScope parserTiming = timing.nest("Parser");
-  OwningOpRef<ModuleOp> module(parseSourceFile(sourceMgr, context));
+  OwningOpRef<ModuleOp> module(parseSourceFile<ModuleOp>(sourceMgr, context));
   context->enableMultithreading(wasThreadingEnabled);
   if (!module)
     return failure();
   parserTiming.stop();
 
   // Apply any pass manager command line options.
   PassManager pm(context, OpPassManager::Nesting::Implicit);
   pm.enableVerifier(verifyPasses);

mlir/lib/Tools/mlir-reduce/MlirReduceMain.cpp

 #include "llvm/Support/ToolOutputFile.h"
 
 using namespace mlir;
 
 // Parse and verify the input MLIR file.
 static LogicalResult loadModule(MLIRContext &context,
                                 OwningOpRef<ModuleOp> &module,
                                 StringRef inputFilename) {
-  module = parseSourceFile(inputFilename, &context);
+  module = parseSourceFile<ModuleOp>(inputFilename, &context);
   if (!module)
     return failure();
 
   return success();
 }
 
 LogicalResult mlir::mlirReduceMain(int argc, char **argv,
                                    MLIRContext &context) {

mlir/lib/Translation/Translation.cpp

TranslateFromMLIRRegistration::TranslateFromMLIRRegistration(
     StringRef name, const TranslateFromMLIRFunction &function,
     const std::function<void(DialectRegistry &)> &dialectRegistration) {
   registerTranslation(name, [function, dialectRegistration](
                                 llvm::SourceMgr &sourceMgr, raw_ostream &output,
                                 MLIRContext *context) {
     DialectRegistry registry;
     dialectRegistration(registry);
     context->appendDialectRegistry(registry);
-    auto module = OwningOpRef<ModuleOp>(parseSourceFile(sourceMgr, context));
+    auto module = parseSourceFile<ModuleOp>(sourceMgr, context);
     if (!module || failed(verify(*module)))
       return failure();
     return function(module.get(), output);
   });
 }
 
 //===----------------------------------------------------------------------===//
 // Translation Parser