[mlir] Add a parsePassPipeline overload that returns a new pass manager

[rriddle]

Summary

This overload parses a pipeline string that contains the anchor operation type, and returns an OpPassManager
corresponding to the provided pipeline. This is useful for various situations, such as dynamic pass pipelines
which are not anchored within a parent pass pipeline.

fixes #52813

[rriddle]

Note; Still need to add test for error message

[jpienaar]

Nice, OOC would referencing the github issue in message result in updating issue?

(test end-to-end with reproducer would be really nice to verify that flow)

[mehdi_amini]

In D116525#3218784, @jpienaar wrote:

Nice, OOC would referencing the github issue in message result in updating issue?

Yes, it'll even recognized many keywords that closes the issue: ://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword

[stellaraccident]

Thanks!

mlir/include/mlir/Pass/PassRegistry.h

registerPassPipeline(
             return failure();
           builder(pm);
           return success();
         },
         [](function_ref<void(const detail::PassOptions &)>) {});
   }
 };
 
-/// This function parses the textual representation of a pass pipeline, and adds
-/// the result to 'pm' on success. This function returns failure if the given
-/// pipeline was invalid. 'errorStream' is the output stream used to emit errors
-/// found during parsing.
+/// Parse the textual representation of a pass pipeline, adding the result to
+/// 'pm' on success. Returns failure if the given pipeline was invalid.
+/// 'errorStream' is the output stream used to emit errors found during parsing.
 LogicalResult parsePassPipeline(StringRef pipeline, OpPassManager &pm,
                                 raw_ostream &errorStream = llvm::errs());
 
+/// Parse the given textual representation of a pass pipeline, and return the
+/// parsed pipeline on success. The given pipeline string should be wrapped with
+/// the desired type of operation to root the created operation, i.e.
+/// `builtin.module(cse)` over `cse`. Returns failure if the given pipeline was
+/// invalid. 'errorStream' is the output stream used to emit errors found during
+/// parsing.
+FailureOr<OpPassManager>
+parsePassPipeline(StringRef pipeline, raw_ostream &errorStream = llvm::errs());
+
 //===----------------------------------------------------------------------===//
 // PassPipelineCLParser
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 struct PassPipelineCLParserImpl;
 } // namespace detail
 

mlir/lib/Pass/PassRegistry.cpp

if (elt.registryEntry) {
                                     errorHandler))) {
       return errorHandler("failed to add `" + elt.name + "` with options `" +
                           elt.options + "` to inner pipeline");
     }
   }
   return success();
 }
 
-/// This function parses the textual representation of a pass pipeline, and adds
-/// the result to 'pm' on success. This function returns failure if the given
-/// pipeline was invalid. 'errorStream' is an optional parameter that, if
-/// non-null, will be used to emit errors found during parsing.
 LogicalResult mlir::parsePassPipeline(StringRef pipeline, OpPassManager &pm,
                                       raw_ostream &errorStream) {
   TextualPipeline pipelineParser;
   if (failed(pipelineParser.initialize(pipeline, errorStream)))
     return failure();
   auto errorHandler = [&](Twine msg) {
     errorStream << msg << "\n";
     return failure();
   };
   if (failed(pipelineParser.addToPipeline(pm, errorHandler)))
     return failure();
   return success();
 }
 
+FailureOr<OpPassManager> mlir::parsePassPipeline(StringRef pipeline,
+                                                 raw_ostream &errorStream) {
+  // Pipelines are expected to be of the form `<op-name>(<pipeline>)`.
+  size_t pipelineStart = pipeline.find_first_of('(');
+  if (pipelineStart == 0 || pipelineStart == StringRef::npos ||
+      !pipeline.consume_back(")")) {
+    errorStream << "expected pass pipeline to be wrapped with the anchor "
+                   "operation type, e.g. `builtin.module(...)";
+    return failure();
+  }
+
+  StringRef opName = pipeline.take_front(pipelineStart);
+  OpPassManager pm(opName);
+  if (failed(parsePassPipeline(pipeline.drop_front(1 + pipelineStart), pm)))
+    return failure();
+  return pm;
+}
+
 //===----------------------------------------------------------------------===//
 // PassNameParser
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// This struct represents the possible data entries in a parsed pass pipeline
 /// list.
 struct PassArgData {

mlir/lib/Transforms/Inliner.cpp

LogicalResult InlinerPass::initializeOptions(StringRef options) {
   }
 
   // Initialize the op specific pass pipelines.
   llvm::StringMap<OpPassManager> pipelines;
   for (StringRef pipeline : opPipelineStrs) {
     // Skip empty pipelines.
     if (pipeline.empty())
       continue;
-
-    // Pipelines are expected to be of the form `<op-name>(<pipeline>)`.
-    size_t pipelineStart = pipeline.find_first_of('(');
-    if (pipelineStart == StringRef::npos || !pipeline.consume_back(")"))
-      return failure();
-    StringRef opName = pipeline.take_front(pipelineStart);
-    OpPassManager pm(opName);
-    if (failed(parsePassPipeline(pipeline.drop_front(1 + pipelineStart), pm)))
+    FailureOr<OpPassManager> pm = parsePassPipeline(pipeline);
+    if (failed(pm))
       return failure();
-    pipelines.try_emplace(opName, std::move(pm));
+    pipelines.try_emplace(pm->getOpName(), std::move(*pm));
   }
   opPipelines.assign({std::move(pipelines)});
 
   return success();
 }
 
 std::unique_ptr<Pass> mlir::createInlinerPass() {
   return std::make_unique<InlinerPass>();

mlir/unittests/Pass/CMakeLists.txt

 add_mlir_unittest(MLIRPassTests
   AnalysisManagerTest.cpp
   PassManagerTest.cpp
+  PassPipelineParserTest.cpp
 )
 target_link_libraries(MLIRPassTests
   PRIVATE
   MLIRPass)

mlir/unittests/Pass/PassPipelineParserTest.cpp

+//===- PassPipelineParserTest.cpp - Pass Parser unit tests ----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Pass/PassManager.h"
+#include "mlir/Pass/PassRegistry.h"
+#include "llvm/Support/raw_ostream.h"
+#include "gtest/gtest.h"
+
+#include <memory>
+
+using namespace mlir;
+using namespace mlir::detail;
+
+namespace {
+TEST(PassPipelineParserTest, InvalidOpAnchor) {
+  // Helper functor used to parse a pipeline and check that it results in the
+  // provided error message.
+  auto checkParseFailure = [](StringRef pipeline, StringRef expectedErrorMsg) {
+    std::string errorMsg;
+    {
+      llvm::raw_string_ostream os(errorMsg);
+      FailureOr<OpPassManager> result = parsePassPipeline(pipeline, os);
+      EXPECT_TRUE(failed(result));
+    }
+    EXPECT_TRUE(StringRef(errorMsg).contains(expectedErrorMsg));
+  };
+
+  // Handle parse errors when the anchor is incorrectly structured.
+  StringRef anchorErrorMsg =
+      "expected pass pipeline to be wrapped with the anchor operation type";
+  checkParseFailure("module", anchorErrorMsg);
+  checkParseFailure("()", anchorErrorMsg);
+  checkParseFailure("module(", anchorErrorMsg);
+  checkParseFailure("module)", anchorErrorMsg);
+}
+
+} // namespace