[flang] Lower complex constructor to HLFIR

[jeanPerier]

Summary

Depends on D139179

[clementval]

LGTM

flang/lib/Lower/ConvertExprToHLFIR.cpp

 #include "flang/Lower/AbstractConverter.h"
 #include "flang/Lower/CallInterface.h"
 #include "flang/Lower/ConvertCall.h"
 #include "flang/Lower/ConvertConstant.h"
 #include "flang/Lower/ConvertType.h"
 #include "flang/Lower/IntrinsicCall.h"
 #include "flang/Lower/StatementContext.h"
 #include "flang/Lower/SymbolMap.h"
+#include "flang/Optimizer/Builder/Complex.h"
 #include "flang/Optimizer/Builder/Runtime/Character.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/HLFIR/HLFIROps.h"
 
 namespace {
 
 /// Lower Designators to HLFIR.
 class HlfirDesignatorBuilder {
case Fortran::evaluate::LogicalOperator::Neqv:
           loc, mlir::arith::CmpIPredicate::ne, i1Lhs, i1Rhs)};
     case Fortran::evaluate::LogicalOperator::Not:
       // lib/evaluate expression for .NOT. is Fortran::evaluate::Not<KIND>.
       llvm_unreachable(".NOT. is not a binary operator");
     }
   }
 };
 
+template <int KIND>
+struct BinaryOp<Fortran::evaluate::ComplexConstructor<KIND>> {
+  using Op = Fortran::evaluate::ComplexConstructor<KIND>;
+  static hlfir::EntityWithAttributes gen(mlir::Location loc,
+                                         fir::FirOpBuilder &builder,
+                                         const Op &op, hlfir::Entity lhs,
+                                         hlfir::Entity rhs) {
+    mlir::Value res =
+        fir::factory::Complex{builder, loc}.createComplex(KIND, lhs, rhs);
+    return hlfir::EntityWithAttributes{res};
+  }
+};
+
 /// Lower Expr to HLFIR.
 class HlfirBuilder {
 public:
   HlfirBuilder(mlir::Location loc, Fortran::lower::AbstractConverter &converter,
                Fortran::lower::SymMap &symMap,
                Fortran::lower::StatementContext &stmtCtx)
       : converter{converter}, symMap{symMap}, stmtCtx{stmtCtx}, loc{loc} {}
 

flang/test/Lower/HLFIR/binary-ops.f90

 ! CHECK:  %[[VAL_10:.*]] = arith.cmpi eq
 
 subroutine logical_neqv(x, y, z)
   logical :: x, y, z
   x = y.neqv.z
 end subroutine
 ! CHECK-LABEL: func.func @_QPlogical_neqv(
 ! CHECK:  %[[VAL_10:.*]] = arith.cmpi ne
+
+subroutine cmplx_ctor(z, x, y)
+  complex :: z
+  real :: x, y
+  z = cmplx(x, y)
+end subroutine
+! CHECK-LABEL: func.func @_QPcmplx_ctor(
+! CHECK:  %[[VAL_3:.*]]:2 = hlfir.declare %{{.*}}x"} : (!fir.ref<f32>) -> (!fir.ref<f32>, !fir.ref<f32>)
+! CHECK:  %[[VAL_4:.*]]:2 = hlfir.declare %{{.*}}y"} : (!fir.ref<f32>) -> (!fir.ref<f32>, !fir.ref<f32>)
+! CHECK:  %[[VAL_6:.*]] = fir.load %[[VAL_3]]#0 : !fir.ref<f32>
+! CHECK:  %[[VAL_7:.*]] = fir.load %[[VAL_4]]#0 : !fir.ref<f32>
+! CHECK:  %[[VAL_8:.*]] = fir.undefined !fir.complex<4>
+! CHECK:  %[[VAL_9:.*]] = fir.insert_value %[[VAL_8]], %[[VAL_6]], [0 : index] : (!fir.complex<4>, f32) -> !fir.complex<4>
+! CHECK:  %[[VAL_10:.*]] = fir.insert_value %[[VAL_9]], %[[VAL_7]], [1 : index] : (!fir.complex<4>, f32) -> !fir.complex<4>
+
+subroutine cmplx_ctor_2(z, x)
+  complex(8) :: z
+  real(8) :: x
+  z = cmplx(x, 1._8, kind=8)
+end subroutine
+! CHECK-LABEL: func.func @_QPcmplx_ctor_2(
+! CHECK:  %[[VAL_2:.*]]:2 = hlfir.declare %{{.*}}x"} : (!fir.ref<f64>) -> (!fir.ref<f64>, !fir.ref<f64>)
+! CHECK:  %[[VAL_4:.*]] = fir.load %[[VAL_2]]#0 : !fir.ref<f64>
+! CHECK:  %[[VAL_5:.*]] = arith.constant 1.000000e+00 : f64
+! CHECK:  %[[VAL_6:.*]] = fir.undefined !fir.complex<8>
+! CHECK:  %[[VAL_7:.*]] = fir.insert_value %[[VAL_6]], %[[VAL_4]], [0 : index] : (!fir.complex<8>, f64) -> !fir.complex<8>
+! CHECK:  %[[VAL_8:.*]] = fir.insert_value %[[VAL_7]], %[[VAL_5]], [1 : index] : (!fir.complex<8>, f64) -> !fir.complex<8>