[flang][NFC] Remove obsolete ComplexExpr helper

[clementval]

Summary

Functionality present in flang/include/flang/Lower/ComplexExpr.h are
available in flang/include/flang/Optimizer/Builder/Complex.h. This patch removes
the obsolete files.

[kiranchandramohan]

LGTM.

flang/include/flang/Lower/ComplexExpr.h

-//===-- Lower/ComplexExpr.h -- lowering of complex values -------*- C++ -*-===//
-//
-// 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 FORTRAN_LOWER_COMPLEXEXPR_H
-#define FORTRAN_LOWER_COMPLEXEXPR_H
-
-#include "flang/Optimizer/Builder/FIRBuilder.h"
-
-namespace Fortran::lower {
-
-/// Helper to facilitate lowering of COMPLEX manipulations in FIR.
-class ComplexExprHelper {
-public:
-  explicit ComplexExprHelper(fir::FirOpBuilder &builder, mlir::Location loc)
-      : builder(builder), loc(loc) {}
-  ComplexExprHelper(const ComplexExprHelper &) = delete;
-
-  // The values of part enum members are meaningful for
-  // InsertValueOp and ExtractValueOp so they are explicit.
-  enum class Part { Real = 0, Imag = 1 };
-
-  /// Type helper. Determine the type. Do not create MLIR operations.
-  mlir::Type getComplexPartType(mlir::Value cplx);
-  mlir::Type getComplexPartType(mlir::Type complexType);
-
-  /// Complex operation creation helper. They create MLIR operations.
-  mlir::Value createComplex(fir::KindTy kind, mlir::Value real,
-                            mlir::Value imag);
-
-  /// Create a complex value.
-  mlir::Value createComplex(mlir::Type complexType, mlir::Value real,
-                            mlir::Value imag);
-
-  mlir::Value extractComplexPart(mlir::Value cplx, bool isImagPart) {
-    return isImagPart ? extract<Part::Imag>(cplx) : extract<Part::Real>(cplx);
-  }
-
-  /// Returns (Real, Imag) pair of \p cplx
-  std::pair<mlir::Value, mlir::Value> extractParts(mlir::Value cplx) {
-    return {extract<Part::Real>(cplx), extract<Part::Imag>(cplx)};
-  }
-
-  mlir::Value insertComplexPart(mlir::Value cplx, mlir::Value part,
-                                bool isImagPart) {
-    return isImagPart ? insert<Part::Imag>(cplx, part)
-                      : insert<Part::Real>(cplx, part);
-  }
-
-  mlir::Value createComplexCompare(mlir::Value cplx1, mlir::Value cplx2,
-                                   bool eq);
-
-protected:
-  template <Part partId>
-  mlir::Value extract(mlir::Value cplx) {
-    return builder.create<fir::ExtractValueOp>(
-        loc, getComplexPartType(cplx), cplx,
-        builder.getArrayAttr({builder.getIntegerAttr(
-            builder.getIndexType(), static_cast<int>(partId))}));
-  }
-
-  template <Part partId>
-  mlir::Value insert(mlir::Value cplx, mlir::Value part) {
-    return builder.create<fir::InsertValueOp>(
-        loc, cplx.getType(), cplx, part,
-        builder.getArrayAttr({builder.getIntegerAttr(
-            builder.getIndexType(), static_cast<int>(partId))}));
-  }
-
-  template <Part partId>
-  mlir::Value createPartId() {
-    return builder.createIntegerConstant(loc, builder.getIndexType(),
-                                         static_cast<int>(partId));
-  }
-
-private:
-  fir::FirOpBuilder &builder;
-  mlir::Location loc;
-};
-
-} // namespace Fortran::lower
-
-#endif // FORTRAN_LOWER_COMPLEXEXPR_H

flang/lib/Lower/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 add_flang_library(FortranLower
   CharacterExpr.cpp
   CharacterRuntime.cpp
   Coarray.cpp
-  ComplexExpr.cpp
   ConvertType.cpp
   IntrinsicCall.cpp
   IO.cpp
   Mangler.cpp
   OpenACC.cpp
   OpenMP.cpp
   PFTBuilder.cpp
 

flang/lib/Lower/ComplexExpr.cpp

-//===-- ComplexExpr.cpp ---------------------------------------------------===//
-//
-// 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 "flang/Lower/ComplexExpr.h"
-#include "flang/Lower/ConvertType.h"
-
-//===----------------------------------------------------------------------===//
-// ComplexExprHelper implementation
-//===----------------------------------------------------------------------===//
-
-mlir::Type
-Fortran::lower::ComplexExprHelper::getComplexPartType(mlir::Type complexType) {
-  return Fortran::lower::convertReal(
-      builder.getContext(), complexType.cast<fir::ComplexType>().getFKind());
-}
-
-mlir::Type
-Fortran::lower::ComplexExprHelper::getComplexPartType(mlir::Value cplx) {
-  return getComplexPartType(cplx.getType());
-}
-
-mlir::Value Fortran::lower::ComplexExprHelper::createComplex(fir::KindTy kind,
-                                                             mlir::Value real,
-                                                             mlir::Value imag) {
-  auto complexTy = fir::ComplexType::get(builder.getContext(), kind);
-  mlir::Value und = builder.create<fir::UndefOp>(loc, complexTy);
-  return insert<Part::Imag>(insert<Part::Real>(und, real), imag);
-}
-
-mlir::Value Fortran::lower::ComplexExprHelper::createComplex(mlir::Type cplxTy,
-                                                             mlir::Value real,
-                                                             mlir::Value imag) {
-  mlir::Value und = builder.create<fir::UndefOp>(loc, cplxTy);
-  return insert<Part::Imag>(insert<Part::Real>(und, real), imag);
-}
-
-mlir::Value Fortran::lower::ComplexExprHelper::createComplexCompare(
-    mlir::Value cplx1, mlir::Value cplx2, bool eq) {
-  auto real1 = extract<Part::Real>(cplx1);
-  auto real2 = extract<Part::Real>(cplx2);
-  auto imag1 = extract<Part::Imag>(cplx1);
-  auto imag2 = extract<Part::Imag>(cplx2);
-
-  mlir::arith::CmpFPredicate predicate =
-      eq ? mlir::arith::CmpFPredicate::UEQ : mlir::arith::CmpFPredicate::UNE;
-  mlir::Value realCmp =
-      builder.create<mlir::arith::CmpFOp>(loc, predicate, real1, real2);
-  mlir::Value imagCmp =
-      builder.create<mlir::arith::CmpFOp>(loc, predicate, imag1, imag2);
-
-  return eq ? builder.create<mlir::arith::AndIOp>(loc, realCmp, imagCmp)
-                  .getResult()
-            : builder.create<mlir::arith::OrIOp>(loc, realCmp, imagCmp)
-                  .getResult();
-}

flang/lib/Lower/IO.cpp

 //===-- IO.cpp -- I/O statement lowering ----------------------------------===//
 //
 // 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 "flang/Lower/IO.h"
 #include "RTBuilder.h"
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/CharacterExpr.h"
-#include "flang/Lower/ComplexExpr.h"
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/Runtime.h"
 #include "flang/Lower/Utils.h"
+#include "flang/Optimizer/Builder/Complex.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Runtime/io-api.h"
 #include "flang/Semantics/tools.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 
 #define TODO() llvm_unreachable("not yet implemented")
 
for (auto &item : items) {
     Fortran::lower::CharacterExprHelper helper{builder, loc};
     if (helper.isCharacter(itemType)) {
       auto dataLen = helper.materializeCharacter(itemValue);
       outputFuncArgs.push_back(builder.createConvert(
           loc, outputFunc.getType().getInput(1), dataLen.first));
       outputFuncArgs.push_back(builder.createConvert(
           loc, outputFunc.getType().getInput(2), dataLen.second));
     } else if (fir::isa_complex(itemType)) {
-      auto parts = Fortran::lower::ComplexExprHelper{builder, loc}.extractParts(
-          itemValue);
+      auto parts = fir::factory::Complex{builder, loc}.extractParts(itemValue);
       outputFuncArgs.push_back(parts.first);
       outputFuncArgs.push_back(parts.second);
     } else {
       itemValue = builder.createConvert(loc, argType, itemValue);
       outputFuncArgs.push_back(itemValue);
     }
     ok = builder.create<mlir::CallOp>(loc, outputFunc, outputFuncArgs)
              .getResult(0);
auto itemAddr =
         converter.genExprAddr(Fortran::semantics::GetExpr(pVar), loc);
     auto itemType = itemAddr.getType().cast<fir::ReferenceType>().getEleTy();
     auto inputFunc = getInputFunc(loc, builder, itemType);
     auto argType = inputFunc.getType().getInput(1);
     auto originalItemAddr = itemAddr;
     mlir::Type complexPartType;
     if (itemType.isa<fir::ComplexType>())
       complexPartType = builder.getRefType(
-          Fortran::lower::ComplexExprHelper{builder, loc}.getComplexPartType(
-              itemType));
+          fir::factory::Complex{builder, loc}.getComplexPartType(itemType));
     auto complexPartAddr = [&](int index) {
       return builder.create<fir::CoordinateOp>(
           loc, complexPartType, originalItemAddr,
           llvm::SmallVector<mlir::Value, 1>{
               builder.create<mlir::arith::ConstantOp>(
                   loc, builder.getI32IntegerAttr(index))});
     };
     if (complexPartType)

flang/lib/Lower/IntrinsicCall.cpp

 // module.
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/IntrinsicCall.h"
 #include "RTBuilder.h"
 #include "flang/Common/static-multimap-view.h"
 #include "flang/Lower/CharacterExpr.h"
-#include "flang/Lower/ComplexExpr.h"
 #include "flang/Lower/ConvertType.h"
 #include "flang/Lower/Mangler.h"
 #include "flang/Lower/Runtime.h"
+#include "flang/Optimizer/Builder/Complex.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
 #include <string_view>
 #include <utility>
 
 #define PGMATH_DECLARE
if (auto intType = type.dyn_cast<mlir::IntegerType>()) {
     auto shift =
         builder.createIntegerConstant(loc, intType, intType.getWidth() - 1);
     auto mask = builder.create<mlir::arith::ShRSIOp>(loc, arg, shift);
     auto xored = builder.create<mlir::arith::XOrIOp>(loc, arg, mask);
     return builder.create<mlir::arith::SubIOp>(loc, xored, mask);
   }
   if (fir::isa_complex(type)) {
     // Use HYPOT to fulfill the no underflow/overflow requirement.
-    auto parts =
-        Fortran::lower::ComplexExprHelper{builder, loc}.extractParts(arg);
+    auto parts = fir::factory::Complex{builder, loc}.extractParts(arg);
     llvm::SmallVector<mlir::Value, 2> args = {parts.first, parts.second};
     return genRuntimeCall("hypot", resultType, args);
   }
   llvm_unreachable("unexpected type in ABS argument");
 }
 
 // AIMAG
 mlir::Value IntrinsicLibrary::genAimag(mlir::Type resultType,
                                        llvm::ArrayRef<mlir::Value> args) {
   assert(args.size() == 1);
-  return Fortran::lower::ComplexExprHelper{builder, loc}.extractComplexPart(
+  return fir::factory::Complex{builder, loc}.extractComplexPart(
       args[0], true /* isImagPart */);
 }
 
 // ANINT
 mlir::Value IntrinsicLibrary::genAnint(mlir::Type resultType,
                                        llvm::ArrayRef<mlir::Value> args) {
   assert(args.size() >= 1);
   // Skip optional kind argument to search the runtime; it is already reflected

 // CONJG
 mlir::Value IntrinsicLibrary::genConjg(mlir::Type resultType,
                                        llvm::ArrayRef<mlir::Value> args) {
   assert(args.size() == 1);
   if (resultType != args[0].getType())
     llvm_unreachable("argument type mismatch");
 
   mlir::Value cplx = args[0];
-  auto imag =
-      Fortran::lower::ComplexExprHelper{builder, loc}.extractComplexPart(
-          cplx, /*isImagPart=*/true);
+  auto imag = fir::factory::Complex{builder, loc}.extractComplexPart(
   auto negImag = builder.create<mlir::arith::NegFOp>(loc, imag);
-  return Fortran::lower::ComplexExprHelper{builder, loc}.insertComplexPart(
+  return fir::factory::Complex{builder, loc}.insertComplexPart(
       cplx, negImag, /*isImagPart=*/true);
 }
 
 // DIM
 mlir::Value IntrinsicLibrary::genDim(mlir::Type resultType,
                                      llvm::ArrayRef<mlir::Value> args) {
   assert(args.size() == 2);
   if (resultType.isa<mlir::IntegerType>()) {