[flang] Fix CMPLX folding with complex arguments

[jeanPerier]

Summary

CMPLX folding was expecting only one arguments in case X argument
is complex. This is wrong since there is also the optional KIND
argument.

flang/lib/Evaluate/fold-complex.cpp

if (auto callable{context.hostIntrinsicsLibrary()
       context.messages().Say(
           "%s(complex(kind=%d)) cannot be folded on host"_en_US, name, KIND);
     }
   } else if (name == "conjg") {
     return FoldElementalIntrinsic<T, T>(
         context, std::move(funcRef), &Scalar<T>::CONJG);
   } else if (name == "cmplx") {
     using Part = typename T::Part;
-    if (args.size() == 1) {
+    if (args.size() == 2) { // CMPLX(X, [KIND])
       if (auto *x{UnwrapExpr<Expr<SomeComplex>>(args[0])}) {
         return Fold(context, ConvertToType<T>(std::move(*x)));
       }
       Expr<SomeType> re{std::move(*args[0].value().UnwrapExpr())};
       Expr<SomeType> im{AsGenericExpr(Constant<Part>{Scalar<Part>{}})};
       return Fold(context,
           Expr<T>{ComplexConstructor<KIND>{ToReal<KIND>(context, std::move(re)),
               ToReal<KIND>(context, std::move(im))}});
     }
-    CHECK(args.size() == 2 || args.size() == 3);
+    // CMPLX(X, [Y, KIND])
+    CHECK(args.size() == 3);
     Expr<SomeType> re{std::move(*args[0].value().UnwrapExpr())};
     Expr<SomeType> im{args[1] ? std::move(*args[1].value().UnwrapExpr())
                               : AsGenericExpr(Constant<Part>{Scalar<Part>{}})};
     return Fold(context,
         Expr<T>{ComplexConstructor<KIND>{ToReal<KIND>(context, std::move(re)),
             ToReal<KIND>(context, std::move(im))}});
   } else if (name == "merge") {
     return FoldMerge<T>(context, std::move(funcRef));

flang/test/Evaluate/folding01.f90

! Check integer relational intrinsic operation folding
   logical, parameter :: test_gt_i5 = -2.GT.-3
 
   logical, parameter :: test_eq_i1 = 2.EQ.2
   logical, parameter :: test_eq_i2 = .NOT.(-2.EQ.2)
 
   logical, parameter :: test_ne_i1 =.NOT.(2.NE.2)
   logical, parameter :: test_ne_i2 = -2.NE.2
 
+! Check conversions
+  logical, parameter :: test_cmplx1 = cmplx((1._4, -1._4)).EQ.((1._4, -1._4))
+  logical, parameter :: test_cmplx2 = cmplx((1._4, -1._4), 8).EQ.((1._8, -1._8))
+  logical, parameter :: test_cmplx3 = cmplx(1._4, -1._4).EQ.((1._4, -1._4))
+  logical, parameter :: test_cmplx4 = cmplx(1._4, -1._4, 8).EQ.((1._8, -1._8))
+  logical, parameter :: test_cmplx5 = cmplx(1._4).EQ.((1._4, 0._4))
+  logical, parameter :: test_cmplx6 = cmplx(1._4, kind=8).EQ.((1._8, 0._8))
+
 ! Check integer intrinsic operation folding
   logical, parameter :: test_unaryminus_i = (-(-1)).EQ.1
   logical, parameter :: test_unaryplus_i = (+1).EQ.1
 
   logical, parameter :: test_plus_i1 = (1+1).EQ.2
   logical, parameter :: test_plus_i2 = ((-3)+1).EQ.-2
 
   logical, parameter :: test_minus_i1 = (1-1).EQ.0