Replace OwningModuleRef with OwningOpRef<ModuleOp>

[sanjoy]

Summary

This addresses a TODO in BuiltinOps.h.

[rriddle]

Nice! OwningModuleRef has deprecated for a while!

mlir/include/mlir/Target/LLVMIR/Import.h

28–29

mlir/examples/toy/Ch2/include/toy/MLIRGen.h

 
 #ifndef TOY_MLIRGEN_H
 #define TOY_MLIRGEN_H
 
 #include <memory>
 
 namespace mlir {
 class MLIRContext;
-class OwningModuleRef;
+template <typename OpTy>
+class OwningOpRef;
+class ModuleOp;
 } // namespace mlir
 
 namespace toy {
 class ModuleAST;
 
 /// Emit IR for the given Toy moduleAST, returns a newly created MLIR module
 /// or nullptr on failure.
-mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context, ModuleAST &moduleAST);
+mlir::OwningOpRef<mlir::ModuleOp> mlirGen(mlir::MLIRContext &context,
+                                          ModuleAST &moduleAST);
 } // namespace toy
 
 #endif // TOY_MLIRGEN_H

mlir/examples/toy/Ch2/mlir/MLIRGen.cpp

private:
   mlir::Type getType(const VarType &type) { return getType(type.shape); }
 };
 
 } // namespace
 
 namespace toy {
 
 // The public API for codegen.
-mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context,
+mlir::OwningOpRef<mlir::ModuleOp> mlirGen(mlir::MLIRContext &context,
                                           ModuleAST &moduleAST) {
   return MLIRGenImpl(context).mlirGen(moduleAST);
 }
 
 } // namespace toy

mlir/examples/toy/Ch2/toyc.cpp

int dumpMLIR() {
   context.getOrLoadDialect<mlir::toy::ToyDialect>();
 
   // Handle '.toy' input to the compiler.
   if (inputType != InputType::MLIR &&
       !llvm::StringRef(inputFilename).endswith(".mlir")) {
     auto moduleAST = parseInputFile(inputFilename);
     if (!moduleAST)
       return 6;
-    mlir::OwningModuleRef module = mlirGen(context, *moduleAST);
+    mlir::OwningOpRef<mlir::ModuleOp> module = mlirGen(context, *moduleAST);
     if (!module)
       return 1;
 
     module->dump();
     return 0;
   }
 
   // Otherwise, the input is '.mlir'.
   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.
   llvm::SourceMgr sourceMgr;
   sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
-  mlir::OwningModuleRef module = mlir::parseSourceFile(sourceMgr, &context);
+  mlir::OwningOpRef<mlir::ModuleOp> module =
+      mlir::parseSourceFile(sourceMgr, &context);
   if (!module) {
     llvm::errs() << "Error can't load file " << inputFilename << "\n";
     return 3;
   }
 
   module->dump();
   return 0;
 }

mlir/examples/toy/Ch3/include/toy/MLIRGen.h

 
 #ifndef TOY_MLIRGEN_H
 #define TOY_MLIRGEN_H
 
 #include <memory>
 
 namespace mlir {
 class MLIRContext;
-class OwningModuleRef;
+template <typename OpTy>
+class OwningOpRef;
+class ModuleOp;
 } // namespace mlir
 
 namespace toy {
 class ModuleAST;
 
 /// Emit IR for the given Toy moduleAST, returns a newly created MLIR module
 /// or nullptr on failure.
-mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context, ModuleAST &moduleAST);
+mlir::OwningOpRef<mlir::ModuleOp> mlirGen(mlir::MLIRContext &context,
+                                          ModuleAST &moduleAST);
 } // namespace toy
 
 #endif // TOY_MLIRGEN_H

mlir/examples/toy/Ch3/mlir/MLIRGen.cpp

private:
   mlir::Type getType(const VarType &type) { return getType(type.shape); }
 };
 
 } // namespace
 
 namespace toy {
 
 // The public API for codegen.
-mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context,
+mlir::OwningOpRef<mlir::ModuleOp> mlirGen(mlir::MLIRContext &context,
                                           ModuleAST &moduleAST) {
   return MLIRGenImpl(context).mlirGen(moduleAST);
 }
 
 } // namespace toy

mlir/examples/toy/Ch3/toyc.cpp

std::unique_ptr<toy::ModuleAST> parseInputFile(llvm::StringRef filename) {
   }
   auto buffer = fileOrErr.get()->getBuffer();
   LexerBuffer lexer(buffer.begin(), buffer.end(), std::string(filename));
   Parser parser(lexer);
   return parser.parseModule();
 }
 
 int loadMLIR(llvm::SourceMgr &sourceMgr, mlir::MLIRContext &context,
-             mlir::OwningModuleRef &module) {
+             mlir::OwningOpRef<mlir::ModuleOp> &module) {
   // Handle '.toy' input to the compiler.
   if (inputType != InputType::MLIR &&
       !llvm::StringRef(inputFilename).endswith(".mlir")) {
     auto moduleAST = parseInputFile(inputFilename);
     if (!moduleAST)
       return 6;
     module = mlirGen(context, *moduleAST);
     return !module ? 1 : 0;
int loadMLIR(llvm::SourceMgr &sourceMgr, mlir::MLIRContext &context,
   return 0;
 }
 
 int dumpMLIR() {
   mlir::MLIRContext context;
   // Load our Dialect in this MLIR Context.
   context.getOrLoadDialect<mlir::toy::ToyDialect>();
 
-  mlir::OwningModuleRef module;
+  mlir::OwningOpRef<mlir::ModuleOp> module;
   llvm::SourceMgr sourceMgr;
   mlir::SourceMgrDiagnosticHandler sourceMgrHandler(sourceMgr, &context);
   if (int error = loadMLIR(sourceMgr, context, module))
     return error;
 
   if (enableOpt) {
     mlir::PassManager pm(&context);
     // Apply any generic pass manager command line options and run the pipeline.

mlir/examples/toy/Ch4/include/toy/MLIRGen.h

 
 #ifndef TOY_MLIRGEN_H
 #define TOY_MLIRGEN_H
 
 #include <memory>
 
 namespace mlir {
 class MLIRContext;
-class OwningModuleRef;
+template <typename OpTy>
+class OwningOpRef;
+class ModuleOp;
 } // namespace mlir
 
 namespace toy {
 class ModuleAST;
 
 /// Emit IR for the given Toy moduleAST, returns a newly created MLIR module
 /// or nullptr on failure.
-mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context, ModuleAST &moduleAST);
+mlir::OwningOpRef<mlir::ModuleOp> mlirGen(mlir::MLIRContext &context,
+                                          ModuleAST &moduleAST);
 } // namespace toy
 
 #endif // TOY_MLIRGEN_H

mlir/examples/toy/Ch4/mlir/MLIRGen.cpp

private:
   mlir::Type getType(const VarType &type) { return getType(type.shape); }
 };
 
 } // namespace
 
 namespace toy {
 
 // The public API for codegen.
-mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context,
+mlir::OwningOpRef<mlir::ModuleOp> mlirGen(mlir::MLIRContext &context,
                                           ModuleAST &moduleAST) {
   return MLIRGenImpl(context).mlirGen(moduleAST);
 }
 
 } // namespace toy

mlir/examples/toy/Ch4/toyc.cpp

std::unique_ptr<toy::ModuleAST> parseInputFile(llvm::StringRef filename) {
   }
   auto buffer = fileOrErr.get()->getBuffer();
   LexerBuffer lexer(buffer.begin(), buffer.end(), std::string(filename));
   Parser parser(lexer);
   return parser.parseModule();
 }
 
 int loadMLIR(llvm::SourceMgr &sourceMgr, mlir::MLIRContext &context,
-             mlir::OwningModuleRef &module) {
+             mlir::OwningOpRef<mlir::ModuleOp> &module) {
   // Handle '.toy' input to the compiler.
   if (inputType != InputType::MLIR &&
       !llvm::StringRef(inputFilename).endswith(".mlir")) {
     auto moduleAST = parseInputFile(inputFilename);
     if (!moduleAST)
       return 6;
     module = mlirGen(context, *moduleAST);
     return !module ? 1 : 0;
int loadMLIR(llvm::SourceMgr &sourceMgr, mlir::MLIRContext &context,
   return 0;
 }
 
 int dumpMLIR() {
   mlir::MLIRContext context;
   // Load our Dialect in this MLIR Context.
   context.getOrLoadDialect<mlir::toy::ToyDialect>();
 
-  mlir::OwningModuleRef module;
+  mlir::OwningOpRef<mlir::ModuleOp> module;
   llvm::SourceMgr sourceMgr;
   mlir::SourceMgrDiagnosticHandler sourceMgrHandler(sourceMgr, &context);
   if (int error = loadMLIR(sourceMgr, context, module))
     return error;
 
   if (enableOpt) {
     mlir::PassManager pm(&context);
     // Apply any generic pass manager command line options and run the pipeline.

mlir/examples/toy/Ch5/include/toy/MLIRGen.h

 
 #ifndef TOY_MLIRGEN_H
 #define TOY_MLIRGEN_H
 
 #include <memory>
 
 namespace mlir {
 class MLIRContext;
-class OwningModuleRef;
+template <typename OpTy>
+class OwningOpRef;
+class ModuleOp;
 } // namespace mlir
 
 namespace toy {
 class ModuleAST;
 
 /// Emit IR for the given Toy moduleAST, returns a newly created MLIR module
 /// or nullptr on failure.
-mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context, ModuleAST &moduleAST);
+mlir::OwningOpRef<mlir::ModuleOp> mlirGen(mlir::MLIRContext &context,
+                                          ModuleAST &moduleAST);
 } // namespace toy
 
 #endif // TOY_MLIRGEN_H

mlir/examples/toy/Ch5/mlir/MLIRGen.cpp

private:
   mlir::Type getType(const VarType &type) { return getType(type.shape); }
 };
 
 } // namespace
 
 namespace toy {
 
 // The public API for codegen.
-mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context,
+mlir::OwningOpRef<mlir::ModuleOp> mlirGen(mlir::MLIRContext &context,
                                           ModuleAST &moduleAST) {
   return MLIRGenImpl(context).mlirGen(moduleAST);
 }
 
 } // namespace toy

mlir/examples/toy/Ch5/toyc.cpp

std::unique_ptr<toy::ModuleAST> parseInputFile(llvm::StringRef filename) {
   }
   auto buffer = fileOrErr.get()->getBuffer();
   LexerBuffer lexer(buffer.begin(), buffer.end(), std::string(filename));
   Parser parser(lexer);
   return parser.parseModule();
 }
 
 int loadMLIR(llvm::SourceMgr &sourceMgr, mlir::MLIRContext &context,
-             mlir::OwningModuleRef &module) {
+             mlir::OwningOpRef<mlir::ModuleOp> &module) {
   // Handle '.toy' input to the compiler.
   if (inputType != InputType::MLIR &&
       !llvm::StringRef(inputFilename).endswith(".mlir")) {
     auto moduleAST = parseInputFile(inputFilename);
     if (!moduleAST)
       return 6;
     module = mlirGen(context, *moduleAST);
     return !module ? 1 : 0;
int loadMLIR(llvm::SourceMgr &sourceMgr, mlir::MLIRContext &context,
   return 0;
 }
 
 int dumpMLIR() {
   mlir::MLIRContext context;
   // Load our Dialect in this MLIR Context.
   context.getOrLoadDialect<mlir::toy::ToyDialect>();
 
-  mlir::OwningModuleRef module;
+  mlir::OwningOpRef<mlir::ModuleOp> module;
   llvm::SourceMgr sourceMgr;
   mlir::SourceMgrDiagnosticHandler sourceMgrHandler(sourceMgr, &context);
   if (int error = loadMLIR(sourceMgr, context, module))
     return error;
 
   mlir::PassManager pm(&context);
   // Apply any generic pass manager command line options and run the pipeline.
   applyPassManagerCLOptions(pm);

mlir/examples/toy/Ch6/include/toy/MLIRGen.h

 
 #ifndef TOY_MLIRGEN_H
 #define TOY_MLIRGEN_H
 
 #include <memory>
 
 namespace mlir {
 class MLIRContext;
-class OwningModuleRef;
+template <typename OpTy>
+class OwningOpRef;
+class ModuleOp;
 } // namespace mlir
 
 namespace toy {
 class ModuleAST;
 
 /// Emit IR for the given Toy moduleAST, returns a newly created MLIR module
 /// or nullptr on failure.
-mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context, ModuleAST &moduleAST);
+mlir::OwningOpRef<mlir::ModuleOp> mlirGen(mlir::MLIRContext &context,
+                                          ModuleAST &moduleAST);
 } // namespace toy
 
 #endif // TOY_MLIRGEN_H

mlir/examples/toy/Ch6/mlir/MLIRGen.cpp

private:
   mlir::Type getType(const VarType &type) { return getType(type.shape); }
 };
 
 } // namespace
 
 namespace toy {
 
 // The public API for codegen.
-mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context,
+mlir::OwningOpRef<mlir::ModuleOp> mlirGen(mlir::MLIRContext &context,
                                           ModuleAST &moduleAST) {
   return MLIRGenImpl(context).mlirGen(moduleAST);
 }
 
 } // namespace toy

mlir/examples/toy/Ch6/toyc.cpp

if (std::error_code ec = fileOrErr.getError()) {
     return nullptr;
   }
   auto buffer = fileOrErr.get()->getBuffer();
   LexerBuffer lexer(buffer.begin(), buffer.end(), std::string(filename));
   Parser parser(lexer);
   return parser.parseModule();
 }
 
-int loadMLIR(mlir::MLIRContext &context, mlir::OwningModuleRef &module) {
+int loadMLIR(mlir::MLIRContext &context,
+             mlir::OwningOpRef<mlir::ModuleOp> &module) {
   // Handle '.toy' input to the compiler.
   if (inputType != InputType::MLIR &&
       !llvm::StringRef(inputFilename).endswith(".mlir")) {
     auto moduleAST = parseInputFile(inputFilename);
     if (!moduleAST)
       return 6;
     module = mlirGen(context, *moduleAST);
     return !module ? 1 : 0;
int loadMLIR(mlir::MLIRContext &context,
   if (!module) {
     llvm::errs() << "Error can't load file " << inputFilename << "\n";
     return 3;
   }
   return 0;
 }
 
 int loadAndProcessMLIR(mlir::MLIRContext &context,
-                       mlir::OwningModuleRef &module) {
+                       mlir::OwningOpRef<mlir::ModuleOp> &module) {
   if (int error = loadMLIR(context, module))
     return error;
 
   mlir::PassManager pm(&context);
   // Apply any generic pass manager command line options and run the pipeline.
   applyPassManagerCLOptions(pm);
 
   // Check to see what granularity of MLIR we are compiling to.
if (emitAction == Action::DumpAST)
     return dumpAST();
 
   // If we aren't dumping the AST, then we are compiling with/to MLIR.
 
   mlir::MLIRContext context;
   // Load our Dialect in this MLIR Context.
   context.getOrLoadDialect<mlir::toy::ToyDialect>();
 
-  mlir::OwningModuleRef module;
+  mlir::OwningOpRef<mlir::ModuleOp> module;
   if (int error = loadAndProcessMLIR(context, module))
     return error;
 
   // If we aren't exporting to non-mlir, then we are done.
   bool isOutputingMLIR = emitAction <= Action::DumpMLIRLLVM;
   if (isOutputingMLIR) {
     module->dump();
     return 0;

mlir/examples/toy/Ch7/include/toy/MLIRGen.h

 
 #ifndef TOY_MLIRGEN_H
 #define TOY_MLIRGEN_H
 
 #include <memory>
 
 namespace mlir {
 class MLIRContext;
-class OwningModuleRef;
+template <typename OpTy>
+class OwningOpRef;
+class ModuleOp;
 } // namespace mlir
 
 namespace toy {
 class ModuleAST;
 
 /// Emit IR for the given Toy moduleAST, returns a newly created MLIR module
 /// or nullptr on failure.
-mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context, ModuleAST &moduleAST);
+mlir::OwningOpRef<mlir::ModuleOp> mlirGen(mlir::MLIRContext &context,
+                                          ModuleAST &moduleAST);
 } // namespace toy
 
 #endif // TOY_MLIRGEN_H

mlir/examples/toy/Ch7/mlir/MLIRGen.cpp

private:
   }
 };
 
 } // namespace
 
 namespace toy {
 
 // The public API for codegen.
-mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context,
+mlir::OwningOpRef<mlir::ModuleOp> mlirGen(mlir::MLIRContext &context,
                                           ModuleAST &moduleAST) {
   return MLIRGenImpl(context).mlirGen(moduleAST);
 }
 
 } // namespace toy

mlir/examples/toy/Ch7/toyc.cpp

if (std::error_code ec = fileOrErr.getError()) {
     return nullptr;
   }
   auto buffer = fileOrErr.get()->getBuffer();
   LexerBuffer lexer(buffer.begin(), buffer.end(), std::string(filename));
   Parser parser(lexer);
   return parser.parseModule();
 }
 
-int loadMLIR(mlir::MLIRContext &context, mlir::OwningModuleRef &module) {
+int loadMLIR(mlir::MLIRContext &context,
+             mlir::OwningOpRef<mlir::ModuleOp> &module) {
   // Handle '.toy' input to the compiler.
   if (inputType != InputType::MLIR &&
       !llvm::StringRef(inputFilename).endswith(".mlir")) {
     auto moduleAST = parseInputFile(inputFilename);
     if (!moduleAST)
       return 6;
     module = mlirGen(context, *moduleAST);
     return !module ? 1 : 0;
int loadMLIR(mlir::MLIRContext &context,
   if (!module) {
     llvm::errs() << "Error can't load file " << inputFilename << "\n";
     return 3;
   }
   return 0;
 }
 
 int loadAndProcessMLIR(mlir::MLIRContext &context,
-                       mlir::OwningModuleRef &module) {
+                       mlir::OwningOpRef<mlir::ModuleOp> &module) {
   if (int error = loadMLIR(context, module))
     return error;
 
   mlir::PassManager pm(&context);
   // Apply any generic pass manager command line options and run the pipeline.
   applyPassManagerCLOptions(pm);
 
   // Check to see what granularity of MLIR we are compiling to.
if (emitAction == Action::DumpAST)
     return dumpAST();
 
   // If we aren't dumping the AST, then we are compiling with/to MLIR.
 
   mlir::MLIRContext context;
   // Load our Dialect in this MLIR Context.
   context.getOrLoadDialect<mlir::toy::ToyDialect>();
 
-  mlir::OwningModuleRef module;
+  mlir::OwningOpRef<mlir::ModuleOp> module;
   if (int error = loadAndProcessMLIR(context, module))
     return error;
 
   // If we aren't exporting to non-mlir, then we are done.
   bool isOutputingMLIR = emitAction <= Action::DumpMLIRLLVM;
   if (isOutputingMLIR) {
     module->dump();
     return 0;

mlir/include/mlir/IR/BuiltinOps.h

 
 //===----------------------------------------------------------------------===//
 // Dialect Operations
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/IR/BuiltinOps.h.inc"
 
-//===----------------------------------------------------------------------===//
-// Dialect Utilities
-//===----------------------------------------------------------------------===//
-
-namespace mlir {
-/// This class acts as an owning reference to a module, and will automatically
-/// destroy the held module on destruction if the held module is valid.
-// TODO: Remove this class in favor of using OwningOpRef directly.
-class OwningModuleRef : public OwningOpRef<ModuleOp> {
-public:
-  using OwningOpRef<ModuleOp>::OwningOpRef;
-  OwningModuleRef() = default;
-  OwningModuleRef(OwningOpRef<ModuleOp> &&other)
-      : OwningOpRef<ModuleOp>(std::move(other)) {}
-};
-} // namespace mlir
-
 namespace llvm {
 /// Allow stealing the low bits of FuncOp.
 template <>
 struct PointerLikeTypeTraits<mlir::FuncOp> {
   static inline void *getAsVoidPointer(mlir::FuncOp val) {
     return const_cast<void *>(val.getAsOpaquePointer());
   }
   static inline mlir::FuncOp getFromVoidPointer(void *p) {

mlir/include/mlir/IR/PatternMatch.h

 /// pattern rewrites specified in the form of the PDL dialect. This PDL module
 /// contained by this pattern may contain any number of `pdl.pattern`
 /// operations.
 class PDLPatternModule {
 public:
   PDLPatternModule() = default;
 
   /// Construct a PDL pattern with the given module.
-  PDLPatternModule(OwningModuleRef pdlModule)
+  PDLPatternModule(OwningOpRef<ModuleOp> pdlModule)
       : pdlModule(std::move(pdlModule)) {}
 
   /// Merge the state in `other` into this pattern module.
   void mergeIn(PDLPatternModule &&other);
 
   /// Return the internal PDL module of this pattern.
   ModuleOp getModule() { return pdlModule.get(); }
 
public:
   void clear() {
     pdlModule = nullptr;
     constraintFunctions.clear();
     rewriteFunctions.clear();
   }
 
 private:
   /// The module containing the `pdl.pattern` operations.
-  OwningModuleRef pdlModule;
+  OwningOpRef<ModuleOp> pdlModule;
 
   /// The external functions referenced from within the PDL module.
   llvm::StringMap<PDLConstraintFunction> constraintFunctions;
   llvm::StringMap<PDLRewriteFunction> rewriteFunctions;
 };
 
 //===----------------------------------------------------------------------===//
 // RewriterBase

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 OwningModuleRef parseSourceFile(const llvm::SourceMgr &sourceMgr,
+inline OwningOpRef<ModuleOp> parseSourceFile(const llvm::SourceMgr &sourceMgr,
                                              MLIRContext *context) {
   return parseSourceFile<ModuleOp>(sourceMgr, context);
 }
-inline OwningModuleRef parseSourceFile(llvm::StringRef filename,
+inline OwningOpRef<ModuleOp> parseSourceFile(llvm::StringRef filename,
                                              MLIRContext *context) {
   return parseSourceFile<ModuleOp>(filename, context);
 }
-inline OwningModuleRef parseSourceFile(llvm::StringRef filename,
+inline OwningOpRef<ModuleOp> parseSourceFile(llvm::StringRef filename,
                                              llvm::SourceMgr &sourceMgr,
                                              MLIRContext *context) {
   return parseSourceFile<ModuleOp>(filename, sourceMgr, context);
 }
-inline OwningModuleRef parseSourceString(llvm::StringRef moduleStr,
+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/include/mlir/Target/LLVMIR/Import.h

 // Forward-declare LLVM classes.
 namespace llvm {
 class Module;
 } // namespace llvm
 
 namespace mlir {
 
 class DialectRegistry;
-class OwningModuleRef;
+
 class MLIRContext;
 
 /// Convert the given LLVM module into MLIR's LLVM dialect.  The LLVM context is
 /// extracted from the registered LLVM IR dialect. In case of error, report it
 /// to the error handler registered with the MLIR context, if any (obtained from
 /// the MLIR module), and return `{}`.
-OwningModuleRef
+OwningOpRef<ModuleOp>
 translateLLVMIRToModule(std::unique_ptr<llvm::Module> llvmModule,
                         MLIRContext *context);
 
 } // namespace mlir
 
 #endif // MLIR_TARGET_LLVMIR_IMPORT_H

mlir/include/mlir/Translation.h

 class StringRef;
 } // namespace llvm
 
 namespace mlir {
 class DialectRegistry;
 struct LogicalResult;
 class MLIRContext;
 class ModuleOp;
-class OwningModuleRef;
+template <typename OpTy>
+class OwningOpRef;
 
 /// Interface of the function that translates the sources managed by `sourceMgr`
 /// to MLIR. The source manager has at least one buffer. The implementation
 /// should create a new MLIR ModuleOp in the given context and return a pointer
 /// to it, or a nullptr in case of any error.
-using TranslateSourceMgrToMLIRFunction =
-    std::function<OwningModuleRef(llvm::SourceMgr &sourceMgr, MLIRContext *)>;
+using TranslateSourceMgrToMLIRFunction = std::function<OwningOpRef<ModuleOp>(
+    llvm::SourceMgr &sourceMgr, MLIRContext *)>;
 
 /// Interface of the function that translates the given string to MLIR. The
 /// implementation should create a new MLIR ModuleOp in the given context. If
 /// source-related error reporting is required from within the function, use
 /// TranslateSourceMgrToMLIRFunction instead.
 using TranslateStringRefToMLIRFunction =
-    std::function<OwningModuleRef(llvm::StringRef, MLIRContext *)>;
+    std::function<OwningOpRef<ModuleOp>(llvm::StringRef, MLIRContext *)>;
 
 /// Interface of the function that translates MLIR to a different format and
 /// outputs the result to a stream. It is allowed to modify the module.
 using TranslateFromMLIRFunction =
     std::function<LogicalResult(ModuleOp, llvm::raw_ostream &output)>;
 
 /// Interface of the function that performs file-to-file translation involving
 /// MLIR. The input file is held in the given MemoryBuffer; the output file

mlir/lib/CAPI/IR/IR.cpp

 // Module API.
 //===----------------------------------------------------------------------===//
 
 MlirModule mlirModuleCreateEmpty(MlirLocation location) {
   return wrap(ModuleOp::create(unwrap(location)));
 }
 
 MlirModule mlirModuleCreateParse(MlirContext context, MlirStringRef module) {
-  OwningModuleRef owning = parseSourceString(unwrap(module), unwrap(context));
+  OwningOpRef<ModuleOp> owning =
+      parseSourceString(unwrap(module), unwrap(context));
   if (!owning)
     return MlirModule{nullptr};
   return MlirModule{owning.release().getOperation()};
 }
 
 MlirContext mlirModuleGetContext(MlirModule module) {
   return wrap(unwrap(module).getContext());
 }
 
 MlirBlock mlirModuleGetBody(MlirModule module) {
   return wrap(unwrap(module).getBody());
 }
 
 void mlirModuleDestroy(MlirModule module) {
-  // Transfer ownership to an OwningModuleRef so that its destructor is called.
-  OwningModuleRef(unwrap(module));
+  // Transfer ownership to an OwningOpRef<ModuleOp> so that its destructor is
+  // called.
+  OwningOpRef<ModuleOp>(unwrap(module));
 }
 
 MlirOperation mlirModuleGetOperation(MlirModule module) {
   return wrap(unwrap(module).getOperation());
 }
 
 MlirModule mlirModuleFromOperation(MlirOperation op) {
   return wrap(dyn_cast<ModuleOp>(unwrap(op)));

mlir/lib/ExecutionEngine/JitRunner.cpp

struct CompileAndExecuteConfig {
   /// A custom function that is passed to ExecutinEngine to register symbols at
   /// runtime.
   llvm::function_ref<llvm::orc::SymbolMap(llvm::orc::MangleAndInterner)>
       runtimeSymbolMap;
 };
 
 } // namespace
 
-static OwningModuleRef parseMLIRInput(StringRef inputFilename,
+static OwningOpRef<ModuleOp> parseMLIRInput(StringRef inputFilename,
                                             MLIRContext *context) {
   // Set up the input file.
   std::string errorMessage;
   auto file = openInputFile(inputFilename, &errorMessage);
   if (!file) {
     llvm::errs() << errorMessage << "\n";
     return nullptr;
   }
 
   llvm::SourceMgr sourceMgr;
   sourceMgr.AddNewSourceBuffer(std::move(file), SMLoc());
-  return OwningModuleRef(parseSourceFile(sourceMgr, context));
+  return OwningOpRef<ModuleOp>(parseSourceFile(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");
-  OwningModuleRef module(parseSourceFile(sourceMgr, context));
+  OwningOpRef<ModuleOp> module(parseSourceFile(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/Target/LLVMIR/ConvertFromLLVMIR.cpp

LogicalResult Importer::processBasicBlock(llvm::BasicBlock *bb, Block *block) {
   b.setInsertionPointToStart(block);
   for (llvm::Instruction &inst : *bb) {
     if (failed(processInstruction(&inst)))
       return failure();
   }
   return success();
 }
 
-OwningModuleRef
+OwningOpRef<ModuleOp>
 mlir::translateLLVMIRToModule(std::unique_ptr<llvm::Module> llvmModule,
                               MLIRContext *context) {
   context->loadDialect<LLVMDialect>();
-  OwningModuleRef module(ModuleOp::create(
+  OwningOpRef<ModuleOp> module(ModuleOp::create(
       FileLineColLoc::get(context, "", /*line=*/0, /*column=*/0)));
 
   Importer deserializer(context, module.get());
   for (llvm::GlobalVariable &gv : llvmModule->globals()) {
     if (!deserializer.processGlobal(&gv))
       return {};
   }
   for (llvm::Function &f : llvmModule->functions()) {
     if (failed(deserializer.processFunction(&f)))
       return {};
   }
 
   return module;
 }
 
 // Deserializes the LLVM bitcode stored in `input` into an MLIR module in the
 // LLVM dialect.
-OwningModuleRef translateLLVMIRToModule(llvm::SourceMgr &sourceMgr,
+OwningOpRef<ModuleOp> translateLLVMIRToModule(llvm::SourceMgr &sourceMgr,
                                               MLIRContext *context) {
   llvm::SMDiagnostic err;
   llvm::LLVMContext llvmContext;
   std::unique_ptr<llvm::Module> llvmModule = llvm::parseIR(
       *sourceMgr.getMemoryBuffer(sourceMgr.getMainFileID()), err, llvmContext);
   if (!llvmModule) {
     std::string errStr;
     llvm::raw_string_ostream errStream(errStr);
     err.print(/*ProgName=*/"", errStream);

mlir/lib/Target/SPIRV/TranslateRegistration.cpp

 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Deserialization registration
 //===----------------------------------------------------------------------===//
 
 // Deserializes the SPIR-V binary module stored in the file named as
 // `inputFilename` and returns a module containing the SPIR-V module.
-static OwningModuleRef deserializeModule(const llvm::MemoryBuffer *input,
+static OwningOpRef<ModuleOp> deserializeModule(const llvm::MemoryBuffer *input,
                                                MLIRContext *context) {
   context->loadDialect<spirv::SPIRVDialect>();
 
   // Make sure the input stream can be treated as a stream of SPIR-V words
   auto *start = input->getBufferStart();
   auto size = input->getBufferSize();
   if (size % sizeof(uint32_t) != 0) {
     emitError(UnknownLoc::get(context))
         << "SPIR-V binary module must contain integral number of 32-bit words";
     return {};
   }
 
   auto binary = llvm::makeArrayRef(reinterpret_cast<const uint32_t *>(start),
                                    size / sizeof(uint32_t));
 
   OwningOpRef<spirv::ModuleOp> spirvModule =
       spirv::deserialize(binary, context);
   if (!spirvModule)
     return {};
 
-  OwningModuleRef module(ModuleOp::create(FileLineColLoc::get(
+  OwningOpRef<ModuleOp> module(ModuleOp::create(FileLineColLoc::get(
       context, input->getBufferIdentifier(), /*line=*/0, /*column=*/0)));
   module->getBody()->push_front(spirvModule.release());
 
   return module;
 }
 
 namespace mlir {
 void registerFromSPIRVTranslation() {
static LogicalResult roundTripModule(ModuleOp srcModule, bool emitDebugInfo,
   deserializationContext.loadAllAvailableDialects();
   // Then deserialize to get back a SPIR-V module.
   OwningOpRef<spirv::ModuleOp> spirvModule =
       spirv::deserialize(binary, &deserializationContext);
   if (!spirvModule)
     return failure();
 
   // Wrap around in a new MLIR module.
-  OwningModuleRef dstModule(ModuleOp::create(
+  OwningOpRef<ModuleOp> dstModule(ModuleOp::create(
       FileLineColLoc::get(&deserializationContext,
                           /*filename=*/"", /*line=*/0, /*column=*/0)));
   dstModule->getBody()->push_front(spirvModule.release());
   dstModule->print(output);
 
   return mlir::success();
 }
 

mlir/lib/Translation/Translation.cpp

 //===----------------------------------------------------------------------===//
 
 // Puts `function` into the to-MLIR translation registry unless there is already
 // a function registered for the same name.
 static void registerTranslateToMLIRFunction(
     StringRef name, const TranslateSourceMgrToMLIRFunction &function) {
   auto wrappedFn = [function](llvm::SourceMgr &sourceMgr, raw_ostream &output,
                               MLIRContext *context) {
-    OwningModuleRef module = function(sourceMgr, context);
+    OwningOpRef<ModuleOp> module = function(sourceMgr, context);
     if (!module || failed(verify(*module)))
       return failure();
     module->print(output);
     return success();
   };
   registerTranslation(name, wrappedFn);
 }
 
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 = OwningModuleRef(parseSourceFile(sourceMgr, context));
+    auto module = OwningOpRef<ModuleOp>(parseSourceFile(sourceMgr, context));
     if (!module || failed(verify(*module)))
       return failure();
     return function(module.get(), output);
   });
 }
 
 //===----------------------------------------------------------------------===//
 // Translation Parser

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);
-  OwningModuleRef module = parseSourceString(moduleStr, &context);
+  OwningOpRef<ModuleOp> module = parseSourceString(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);
-  OwningModuleRef module = parseSourceString(moduleStr, &context);
+  OwningOpRef<ModuleOp> module = parseSourceString(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 @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);
-  OwningModuleRef module = parseSourceString(moduleStr, &context);
+  OwningOpRef<ModuleOp> module = parseSourceString(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);

mlir/unittests/Interfaces/ControlFlowInterfacesTest.cpp

"cftest.mutually_exclusive_regions_op"() (
       {"cftest.dummy_op"() : () -> ()}   // op2
   ) : () -> ()
   )MLIR";
 
   DialectRegistry registry;
   registry.insert<CFTestDialect>();
   MLIRContext ctx(registry);
 
-  OwningModuleRef module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString(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);
 
-  OwningModuleRef module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString(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);
 
-  OwningModuleRef module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString(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);
 
-  OwningModuleRef module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString(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);
 
-  OwningModuleRef module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString(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);
 
-  OwningModuleRef module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString(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);
 
-  OwningModuleRef module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString(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);
 
-  OwningModuleRef module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString(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);
 
-  OwningModuleRef module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString(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);
 
-  OwningModuleRef module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString(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);
 
-  OwningModuleRef module = parseSourceString(ir, &ctx);
+  OwningOpRef<ModuleOp> module = parseSourceString(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

protected:
   // Create ValueShapeRange on the arith.addi operation.
   ValueShapeRange addiRange() {
     auto &fnBody = mapFn.body();
     return std::next(fnBody.front().begin())->getOperands();
   }
 
   DialectRegistry registry;
   MLIRContext ctx;
-  OwningModuleRef module;
+  OwningOpRef<ModuleOp> module;
   FuncOp mapFn;
 };
 
 TEST_F(ValueShapeRangeTest, ShapesFromValues) {
   ValueShapeRange range = addiRange();
 
   EXPECT_FALSE(range.getValueAsShape(0));
   ASSERT_TRUE(range.getValueAsShape(1));

mlir/unittests/Pass/AnalysisManagerTest.cpp

 struct OpSpecificAnalysis {
   OpSpecificAnalysis(ModuleOp) {}
 };
 
 TEST(AnalysisManagerTest, FineGrainModuleAnalysisPreservation) {
   MLIRContext context;
 
   // Test fine grain invalidation of the module analysis manager.
-  OwningModuleRef module(ModuleOp::create(UnknownLoc::get(&context)));
+  OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
   ModuleAnalysisManager mam(*module, /*passInstrumentor=*/nullptr);
   AnalysisManager am = mam;
 
   // Query two different analyses, but only preserve one before invalidating.
   am.getAnalysis<MyAnalysis>();
   am.getAnalysis<OtherAnalysis>();
 
   detail::PreservedAnalyses pa;
   pa.preserve<MyAnalysis>();
   am.invalidate(pa);
 
   // Check that only MyAnalysis is preserved.
   EXPECT_TRUE(am.getCachedAnalysis<MyAnalysis>().hasValue());
   EXPECT_FALSE(am.getCachedAnalysis<OtherAnalysis>().hasValue());
 }
 
 TEST(AnalysisManagerTest, FineGrainFunctionAnalysisPreservation) {
   MLIRContext context;
   Builder builder(&context);
 
   // Create a function and a module.
-  OwningModuleRef module(ModuleOp::create(UnknownLoc::get(&context)));
+  OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
   FuncOp func1 =
       FuncOp::create(builder.getUnknownLoc(), "foo",
                      builder.getFunctionType(llvm::None, llvm::None));
   func1.setPrivate();
   module->push_back(func1);
 
   // Test fine grain invalidation of the function analysis manager.
   ModuleAnalysisManager mam(*module, /*passInstrumentor=*/nullptr);
TEST(AnalysisManagerTest, FineGrainFunctionAnalysisPreservation) {
   EXPECT_FALSE(fam.getCachedAnalysis<OtherAnalysis>().hasValue());
 }
 
 TEST(AnalysisManagerTest, FineGrainChildFunctionAnalysisPreservation) {
   MLIRContext context;
   Builder builder(&context);
 
   // Create a function and a module.
-  OwningModuleRef module(ModuleOp::create(UnknownLoc::get(&context)));
+  OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
   FuncOp func1 =
       FuncOp::create(builder.getUnknownLoc(), "foo",
                      builder.getFunctionType(llvm::None, llvm::None));
   func1.setPrivate();
   module->push_back(func1);
 
   // Test fine grain invalidation of a function analysis from within a module
   // analysis manager.
struct CustomInvalidatingAnalysis {
   }
 };
 
 TEST(AnalysisManagerTest, CustomInvalidation) {
   MLIRContext context;
   Builder builder(&context);
 
   // Create a function and a module.
-  OwningModuleRef module(ModuleOp::create(UnknownLoc::get(&context)));
+  OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
   ModuleAnalysisManager mam(*module, /*passInstrumentor=*/nullptr);
   AnalysisManager am = mam;
 
   detail::PreservedAnalyses pa;
 
   // Check that the analysis is invalidated properly.
   am.getAnalysis<CustomInvalidatingAnalysis>();
   am.invalidate(pa);
   EXPECT_FALSE(am.getCachedAnalysis<CustomInvalidatingAnalysis>().hasValue());
 
   // Check that the analysis is preserved properly.
   am.getAnalysis<CustomInvalidatingAnalysis>();
   pa.preserve<TestAnalysisSet>();
   am.invalidate(pa);
   EXPECT_TRUE(am.getCachedAnalysis<CustomInvalidatingAnalysis>().hasValue());
 }
 
 TEST(AnalysisManagerTest, OpSpecificAnalysis) {
   MLIRContext context;
 
   // Create a module.
-  OwningModuleRef module(ModuleOp::create(UnknownLoc::get(&context)));
+  OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
   ModuleAnalysisManager mam(*module, /*passInstrumentor=*/nullptr);
   AnalysisManager am = mam;
 
   // Query the op specific analysis for the module and verify that its cached.
   am.getAnalysis<OpSpecificAnalysis, ModuleOp>();
   EXPECT_TRUE(am.getCachedAnalysis<OpSpecificAnalysis>().hasValue());
 }
 
 struct AnalysisWithDependency {
   AnalysisWithDependency(Operation *, AnalysisManager &am) {
     am.getAnalysis<MyAnalysis>();
   }
 
   bool isInvalidated(const AnalysisManager::PreservedAnalyses &pa) {
     return !pa.isPreserved<AnalysisWithDependency>() ||
            !pa.isPreserved<MyAnalysis>();
   }
 };
 
 TEST(AnalysisManagerTest, DependentAnalysis) {
   MLIRContext context;
 
   // Create a module.
-  OwningModuleRef module(ModuleOp::create(UnknownLoc::get(&context)));
+  OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
   ModuleAnalysisManager mam(*module, /*passInstrumentor=*/nullptr);
   AnalysisManager am = mam;
 
   am.getAnalysis<AnalysisWithDependency>();
   EXPECT_TRUE(am.getCachedAnalysis<AnalysisWithDependency>().hasValue());
   EXPECT_TRUE(am.getCachedAnalysis<MyAnalysis>().hasValue());
 
   detail::PreservedAnalyses pa;
return !pa.isPreserved<AnalysisWithNestedDependency>() ||
            !pa.isPreserved<AnalysisWithDependency>();
   }
 };
 
 TEST(AnalysisManagerTest, NestedDependentAnalysis) {
   MLIRContext context;
 
   // Create a module.
-  OwningModuleRef module(ModuleOp::create(UnknownLoc::get(&context)));
+  OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
   ModuleAnalysisManager mam(*module, /*passInstrumentor=*/nullptr);
   AnalysisManager am = mam;
 
   am.getAnalysis<AnalysisWithNestedDependency>();
   EXPECT_TRUE(am.getCachedAnalysis<AnalysisWithNestedDependency>().hasValue());
   EXPECT_TRUE(am.getCachedAnalysis<AnalysisWithDependency>().hasValue());
   EXPECT_TRUE(am.getCachedAnalysis<MyAnalysis>().hasValue());
 
struct AnalysisWith2Ctors {
   bool ctor1called = false;
   bool ctor2called = false;
 };
 
 TEST(AnalysisManagerTest, DependentAnalysis2Ctors) {
   MLIRContext context;
 
   // Create a module.
-  OwningModuleRef module(ModuleOp::create(UnknownLoc::get(&context)));
+  OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
   ModuleAnalysisManager mam(*module, /*passInstrumentor=*/nullptr);
   AnalysisManager am = mam;
 
   auto &an = am.getAnalysis<AnalysisWith2Ctors>();
   EXPECT_FALSE(an.ctor1called);
   EXPECT_TRUE(an.ctor2called);
 }
 
 } // namespace

mlir/unittests/Pass/PassManagerTest.cpp

struct AnnotateFunctionPass
   }
 };
 
 TEST(PassManagerTest, OpSpecificAnalysis) {
   MLIRContext context;
   Builder builder(&context);
 
   // Create a module with 2 functions.
-  OwningModuleRef module(ModuleOp::create(UnknownLoc::get(&context)));
+  OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
   for (StringRef name : {"secret", "not_secret"}) {
     FuncOp func =
         FuncOp::create(builder.getUnknownLoc(), name,
                        builder.getFunctionType(llvm::None, llvm::None));
     func.setPrivate();
     module->push_back(func);
   }
 

 };
 } // namespace
 
 TEST(PassManagerTest, InvalidPass) {
   MLIRContext context;
   context.allowUnregisteredDialects();
 
   // Create a module
-  OwningModuleRef module(ModuleOp::create(UnknownLoc::get(&context)));
+  OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
 
   // Add a single "invalid_op" operation
   OpBuilder builder(&module->getBodyRegion());
   OperationState state(UnknownLoc::get(&context), "invalid_op");
   builder.insert(Operation::create(state));
 
   // Register a diagnostic handler to capture the diagnostic so that we can
   // check it later.

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";
 
-  OwningModuleRef module = mlir::parseSourceString(code, &context);
+  OwningOpRef<ModuleOp> module = mlir::parseSourceString(code, &context);
   ASSERT_TRUE(succeeded(mgr.run(*module)));
 
   EXPECT_TRUE(module->lookupSymbol("B"));
   EXPECT_FALSE(module->lookupSymbol("A"));
 }
 
 } // end anonymous namespace