[mlir] Add conversion function from OwningOpRef<T> to OwningOpRef<Operation *>

mlir/include/mlir/IR/OwningOpRef.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_OWNINGOPREF_H
 #define MLIR_IR_OWNINGOPREF_H
 
 #include <utility>
 
 namespace mlir {
+class Operation;
 
 /// This class acts as an owning reference to an op, and will automatically
 /// destroy the held op on destruction if the held op is valid.
 ///
 /// Note that OpBuilder and related functionality should be highly preferred
 /// instead, and this should only be used in situations where existing solutions
 /// are not viable.
 template <typename OpTy>
public:
   }
 
   /// Allow accessing the internal op.
   OpTy get() const { return op; }
   OpTy operator*() const { return op; }
   OpTy *operator->() { return &op; }
   explicit operator bool() const { return op; }
 
+  /// Downcast to generic operation.
+  operator OwningOpRef<Operation *>() && { return release().getOperation(); }
+
   /// Release the referenced op.
   OpTy release() {
     OpTy released(nullptr);
     std::swap(released, op);
     return released;
   }
 
 private:
   OpTy op;
 };
 
 } // namespace mlir
 
 #endif // MLIR_IR_OWNINGOPREF_H

mlir/include/mlir/Tools/ParseUtilties.h

 /// error handler registered in the context.
 /// If 'insertImplicitModule' is true a top-level 'builtin.module' op will be
 /// inserted that contains the parsed IR, unless one exists already.
 inline OwningOpRef<Operation *>
 parseSourceFileForTool(llvm::SourceMgr &sourceMgr, const ParserConfig &config,
                        bool insertImplicitModule) {
   if (insertImplicitModule) {
     // TODO: Move implicit module logic out of 'parseSourceFile' and into here.
-    return parseSourceFile<ModuleOp>(sourceMgr, config)
-        .release()
-        .getOperation();
+    return parseSourceFile<ModuleOp>(sourceMgr, config);
   }
   return parseSourceFile(sourceMgr, config);
 }
 } // namespace mlir
 
 #endif // MLIR_TOOLS_PARSEUTILITIES_H