[mlir][NFC] Make test-lower-to-llvm a named pipeline

[qcolombet]

Summary

This patch changes the test-lower-to-llvm pass into a named pipeline.
The functionality is unchanged but thanks to this change, we don't have to pull the dependencies of all the passes that this pass calls.
In other words, TestLowerToLLVMPass::getDependDialects was supposed to transitively declare all the dialects that were used in the union of all the invoked passes.

NFC

mlir/test/lib/Dialect/LLVM/TestLowerToLLVM.cpp

 #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
 #include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/IR/DialectRegistry.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
+#include "mlir/Pass/PassOptions.h"
 #include "mlir/Transforms/Passes.h"
 
 using namespace mlir;
 
 namespace {
-struct TestLowerToLLVM
-    : public PassWrapper<TestLowerToLLVM, OperationPass<ModuleOp>> {
-  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLowerToLLVM)
-
-  TestLowerToLLVM() = default;
-  TestLowerToLLVM(const TestLowerToLLVM &pass) : PassWrapper(pass) {}
-
-  StringRef getArgument() const final { return "test-lower-to-llvm"; }
-  StringRef getDescription() const final {
-    return "Test lowering to LLVM as a generally usable sink pass";
-  }
-  void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<LLVM::LLVMDialect>();
-  }
-
-  Option<bool> reassociateFPReductions{
+struct TestLowerToLLVMOptions
+    : public PassPipelineOptions<TestLowerToLLVMOptions> {
+  PassOptions::Option<bool> reassociateFPReductions{
       *this, "reassociate-fp-reductions",
       llvm::cl::desc("Allow reassociation og FP reductions"),
       llvm::cl::init(false)};
-
-  void runOnOperation() final;
 };
-} // namespace
 
-void TestLowerToLLVM::runOnOperation() {
-  MLIRContext *context = &this->getContext();
-  RewritePatternSet patterns(context);
+void buildTestLowerToLLVM(OpPassManager &pm,
+                          const TestLowerToLLVMOptions &options) {
 
   // TODO: it is feasible to scope lowering at arbitrary level and introduce
   // unrealized casts, but there needs to be the final module-wise cleanup in
   // the end. Keep module-level for now.
-  PassManager pm(&getContext());
 
   // Blanket-convert any remaining high-level vector ops to loops if any remain.
   pm.addNestedPass<func::FuncOp>(createConvertVectorToSCFPass());
   // Blanket-convert any remaining linalg ops to loops if any remain.
   pm.addNestedPass<func::FuncOp>(createConvertLinalgToLoopsPass());
   // Blanket-convert any remaining affine ops if any remain.
   pm.addPass(createLowerAffinePass());
   // Convert SCF to CF (always needed).
   pm.addPass(createConvertSCFToCFPass());
   // Sprinkle some cleanups.
   pm.addPass(createCanonicalizerPass());
   pm.addPass(createCSEPass());
   // Blanket-convert any remaining linalg ops to LLVM if any remain.
   pm.addPass(createConvertLinalgToLLVMPass());
   // Convert vector to LLVM (always needed).
   pm.addPass(createConvertVectorToLLVMPass(
       // TODO: add more options on a per-need basis.
       LowerVectorToLLVMOptions().enableReassociateFPReductions(
-          reassociateFPReductions)));
+          options.reassociateFPReductions)));
   // Convert Math to LLVM (always needed).
   pm.addNestedPass<func::FuncOp>(createConvertMathToLLVMPass());
   // Convert MemRef to LLVM (always needed).
   pm.addPass(createMemRefToLLVMConversionPass());
   // Convert Func to LLVM (always needed).
   pm.addPass(createConvertFuncToLLVMPass());
   // Convert Index to LLVM (always needed).
   pm.addPass(createConvertIndexToLLVMPass());
   // Convert remaining unrealized_casts (always needed).
   pm.addPass(createReconcileUnrealizedCastsPass());
-  if (failed(pm.run(getOperation()))) {
-    getOperation()->dump();
-    return signalPassFailure();
-  }
 }
+} // namespace
 
 namespace mlir {
 namespace test {
-void registerTestLowerToLLVM() { PassRegistration<TestLowerToLLVM>(); }
+void registerTestLowerToLLVM() {
+  PassPipelineRegistration<TestLowerToLLVMOptions>(
+      "test-lower-to-llvm",
+      "An example of pipeline to lower the main dialects (arith, linalg, "
+      "memref, scf, vector) down to LLVM.",
+      buildTestLowerToLLVM);
+}
 } // namespace test
 } // namespace mlir