[flang] Fix folding of CMPLX

[klausler]

Summary

The code for folding calls to the intrinsic function CMPLX was
incorrectly dependent on the number of arguments to distinguish its
two cases (conversion from one kind of complex to another, and
composition of a complex value from real & imaginary parts).
This was wrong since the optional KIND= argument has already been
taken into account by intrinsic processing; instead, the type of
the first argument should decide the issue.

[PeteSteinfeld]

All builds, tests, and looks good.

flang/lib/Evaluate/fold-complex.cpp

if (name == "acos" || name == "acosh" || name == "asin" || name == "asinh" ||
     } else {
       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() == 2) { // CMPLX(X, [KIND])
+    if (args.size() > 0 && args[0].has_value()) {
       if (auto *x{UnwrapExpr<Expr<SomeComplex>>(args[0])}) {
+        // CMPLX(X [, KIND]) with complex X
         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))}});
-    }
-    // CMPLX(X, [Y, KIND])
-    CHECK(args.size() == 3);
+      } else {
+        // CMPLX(X [, Y [, KIND]]) with non-complex X
+        using Part = typename T::Part;
         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>{}})};
+        Expr<SomeType> im{args.size() >= 2 && args[1].has_value()
+                ? std::move(*args[1]->UnwrapExpr())
         return Fold(context,
-        Expr<T>{ComplexConstructor<KIND>{ToReal<KIND>(context, std::move(re)),
+            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));
   }
   // TODO: cshift, dot_product, eoshift, matmul, pack, product,
   // reduce, spread, sum, transfer, transpose, unpack
   return Expr<T>{std::move(funcRef)};
 }