[mlir] Change ComplexToLLVM to be a generic pass

[rriddle]

Summary

It is currently a module pass, but shouldn't be. All of the patterns
are local conversions, and don't require anything about
functions/modules.

[mehdi_amini]

Seems like the kind of things you can skip review really :)

mlir/include/mlir/Conversion/ComplexToLLVM/ComplexToLLVM.h

 //===- ComplexToLLVM.h - Utils to convert from the complex dialect --------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 #ifndef MLIR_CONVERSION_COMPLEXTOLLVM_COMPLEXTOLLVM_H_
 #define MLIR_CONVERSION_COMPLEXTOLLVM_COMPLEXTOLLVM_H_
 
 #include "mlir/Conversion/LLVMCommon/StructBuilder.h"
 
 namespace mlir {
 class LLVMTypeConverter;
-class ModuleOp;
-template <typename T>
-class OperationPass;
+class Pass;
 class RewritePatternSet;
 
 class ComplexStructBuilder : public StructBuilder {
 public:
   /// Construct a helper for the given complex number value.
   using StructBuilder::StructBuilder;
   /// Build IR creating an `undef` value of the complex number type.
   static ComplexStructBuilder undef(OpBuilder &builder, Location loc,
public:
   void setImaginary(OpBuilder &builder, Location loc, Value imaginary);
 };
 
 /// Populate the given list with patterns that convert from Complex to LLVM.
 void populateComplexToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                              RewritePatternSet &patterns);
 
 /// Create a pass to convert Complex operations to the LLVMIR dialect.
-std::unique_ptr<OperationPass<ModuleOp>> createConvertComplexToLLVMPass();
+std::unique_ptr<Pass> createConvertComplexToLLVMPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_COMPLEXTOLLVM_COMPLEXTOLLVM_H_

mlir/include/mlir/Conversion/Passes.td

def ConvertBufferizationToMemRef : Pass<"convert-bufferization-to-memref"> {
   let constructor = "mlir::createBufferizationToMemRefPass()";
   let dependentDialects = ["arith::ArithmeticDialect", "memref::MemRefDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // ComplexToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertComplexToLLVM : Pass<"convert-complex-to-llvm", "ModuleOp"> {
+def ConvertComplexToLLVM : Pass<"convert-complex-to-llvm"> {
   let summary = "Convert Complex dialect to LLVM dialect";
   let constructor = "mlir::createConvertComplexToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // ComplexToStandard
 //===----------------------------------------------------------------------===//

mlir/lib/Conversion/ComplexToLLVM/ComplexToLLVM.cpp

 namespace {
 struct ConvertComplexToLLVMPass
     : public ConvertComplexToLLVMBase<ConvertComplexToLLVMPass> {
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertComplexToLLVMPass::runOnOperation() {
-  auto module = getOperation();
-
   // Convert to the LLVM IR dialect using the converter defined above.
   RewritePatternSet patterns(&getContext());
   LLVMTypeConverter converter(&getContext());
   populateComplexToLLVMConversionPatterns(converter, patterns);
 
   LLVMConversionTarget target(getContext());
-  target.addLegalOp<ModuleOp, FuncOp>();
   target.addIllegalDialect<complex::ComplexDialect>();
-  if (failed(applyPartialConversion(module, target, std::move(patterns))))
+  if (failed(
+          applyPartialConversion(getOperation(), target, std::move(patterns))))
     signalPassFailure();
 }
 
-std::unique_ptr<OperationPass<ModuleOp>>
-mlir::createConvertComplexToLLVMPass() {
+std::unique_ptr<Pass> mlir::createConvertComplexToLLVMPass() {
   return std::make_unique<ConvertComplexToLLVMPass>();
 }