Add a clear() method on the PassManager (NFC)

[mehdi_amini]

Summary

This allows to clear an OpPassManager and populated it again with a new
pipeline, while preserving all the other options (including instrumentations).

mlir/include/mlir/Pass/PassManager.h

public:
   template <typename OpT> OpPassManager &nest() {
     return nest(OpT::getOperationName());
   }
 
   /// Add the given pass to this pass manager. If this pass has a concrete
   /// operation type, it must be the same type as this pass manager.
   void addPass(std::unique_ptr<Pass> pass);
 
+  /// Clear the pipeline, but not the other options set on this OpPassManager.
+  void clear();
+
   /// Add the given pass to a nested pass manager for the given operation kind
   /// `OpT`.
   template <typename OpT> void addNestedPass(std::unique_ptr<Pass> pass) {
     nest<OpT>().addPass(std::move(pass));
   }
 
   /// Returns the number of passes held by this manager.
   size_t size() const;

mlir/lib/Pass/Pass.cpp

struct OpPassManagerImpl {
   /// pass manager.
   OpPassManager &nest(Identifier nestedName);
   OpPassManager &nest(StringRef nestedName);
 
   /// Add the given pass to this pass manager. If this pass has a concrete
   /// operation type, it must be the same type as this pass manager.
   void addPass(std::unique_ptr<Pass> pass);
 
+  /// Clear the list of passes in this pass manager, other options are
+  /// preserved.
+  void clear();
+
   /// Coalesce adjacent AdaptorPasses into one large adaptor. This runs
   /// recursively through the pipeline graph.
   void coalesceAdjacentAdaptorPasses();
 
   /// Return the operation name of this pass manager as an identifier.
   Identifier getOpName(MLIRContext &context) {
     if (!identifier)
       identifier = Identifier::get(name, &context);
llvm::report_fatal_error(llvm::Twine("Can't add pass '") + pass->getName() +
                              "' restricted to '" + *passOpName +
                              "' on a PassManager intended to run on '" + name +
                              "', did you intend to nest?");
   }
 
   passes.emplace_back(std::move(pass));
 }
 
+void OpPassManagerImpl::clear() { passes.clear(); }
+
 void OpPassManagerImpl::coalesceAdjacentAdaptorPasses() {
   // Bail out early if there are no adaptor passes.
   if (llvm::none_of(passes, [](std::unique_ptr<Pass> &pass) {
         return isa<OpToOpPassAdaptor>(pass.get());
       }))
     return;
 
   // Walk the pass list and merge adjacent adaptors.

 }
 
 /// Add the given pass to this pass manager. If this pass has a concrete
 /// operation type, it must be the same type as this pass manager.
 void OpPassManager::addPass(std::unique_ptr<Pass> pass) {
   impl->addPass(std::move(pass));
 }
 
+void OpPassManager::clear() { impl->clear(); }
+
 /// Returns the number of passes held by this manager.
 size_t OpPassManager::size() const { return impl->passes.size(); }
 
 /// Returns the internal implementation instance.
 OpPassManagerImpl &OpPassManager::getImpl() { return *impl; }
 
 /// Return the operation name that this pass manager operates on.
 StringRef OpPassManager::getOpName() const { return impl->name; }

mlir/unittests/Pass/PassManagerTest.cpp

TEST(PassManagerTest, InvalidPass) {
   pm.nest("invalid_op").addPass(std::make_unique<InvalidPass>());
   LogicalResult result = pm.run(module.get());
   EXPECT_TRUE(failed(result));
   ASSERT_TRUE(diagnostic.get() != nullptr);
   EXPECT_EQ(
       diagnostic->str(),
       "'invalid_op' op trying to schedule a pass on an unregistered operation");
 
+  // Check that clearing the pass manager effectively removed the pass.
+  pm.clear();
+  result = pm.run(module.get());
+  EXPECT_TRUE(succeeded(result));
+
   // Check that adding the pass at the top-level triggers a fatal error.
   ASSERT_DEATH(pm.addPass(std::make_unique<InvalidPass>()), "");
 }
 
 } // end namespace