[flang] Fix folding of character array kind conversion

[klausler]

Summary

The folding of conversions of character arrays from one kind to
another was not preserving the value of the character length expression
on the intermediate array constructor, causing spurious errors
when defining named constant arrays of one kind of character with
arrays of another kind.

Fixes llvm-test-suite/Fortran/gfortran/regression/widechar_10.f90.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Evaluate/fold-implementation.h

 // to each of their corresponding elements to produce a flat
 // ArrayConstructor<RESULT> (wrapped in an Expr<RESULT>).
 // Preserves shape.
 
 // Unary case
 template <typename RESULT, typename OPERAND>
 std::optional<Expr<RESULT>> MapOperation(FoldingContext &context,
     std::function<Expr<RESULT>(Expr<OPERAND> &&)> &&f, const Shape &shape,
+    [[maybe_unused]] std::optional<Expr<SubscriptInteger>> &&length,
     Expr<OPERAND> &&values) {
   ArrayConstructor<RESULT> result{values};
   if constexpr (common::HasMember<OPERAND, AllIntrinsicCategoryTypes>) {
     common::visit(
         [&](auto &&kindExpr) {
           using kindType = ResultType<decltype(kindExpr)>;
           auto &aConst{std::get<ArrayConstructor<kindType>>(kindExpr.u)};
           for (auto &acValue : aConst) {
             auto &scalar{std::get<Expr<kindType>>(acValue.u)};
             result.Push(Fold(context, f(Expr<OPERAND>{std::move(scalar)})));
           }
         },
         std::move(values.u));
   } else {
     auto &aConst{std::get<ArrayConstructor<OPERAND>>(values.u)};
     for (auto &acValue : aConst) {
       auto &scalar{std::get<Expr<OPERAND>>(acValue.u)};
       result.Push(Fold(context, f(std::move(scalar))));
     }
   }
+  if constexpr (RESULT::category == TypeCategory::Character) {
+    if (length) {
+      result.set_LEN(std::move(*length));
+    }
+  }
   return FromArrayConstructor(context, std::move(result), shape);
 }
 
 template <typename RESULT, typename A>
 ArrayConstructor<RESULT> ArrayConstructorFromMold(
     const A &prototype, std::optional<Expr<SubscriptInteger>> &&length) {
   ArrayConstructor<RESULT> result{prototype};
   if constexpr (RESULT::category == TypeCategory::Character) {
for (auto &rightValue : rightArrConst) {
       auto &rightScalar{std::get<Expr<RIGHT>>(rightValue.u)};
       result.Push(
           Fold(context, f(Expr<LEFT>{leftScalar}, std::move(rightScalar))));
     }
   }
   return FromArrayConstructor(context, std::move(result), shape);
 }
 
-template <typename DERIVED, typename RESULT, typename LEFT, typename RIGHT>
+template <typename DERIVED, typename RESULT, typename... OPD>
 std::optional<Expr<SubscriptInteger>> ComputeResultLength(
-    Operation<DERIVED, RESULT, LEFT, RIGHT> &operation) {
+    Operation<DERIVED, RESULT, OPD...> &operation) {
   if constexpr (RESULT::category == TypeCategory::Character) {
     return Expr<RESULT>{operation.derived()}.LEN();
   }
   return std::nullopt;
 }
 
 // ApplyElementwise() recursively folds the operand expression(s) of an
 // operation, then attempts to apply the operation to the (corresponding)
 // scalar element(s) of those operands.  Returns std::nullopt for scalars
 // or unlinearizable operands.
 template <typename DERIVED, typename RESULT, typename OPERAND>
 auto ApplyElementwise(FoldingContext &context,
     Operation<DERIVED, RESULT, OPERAND> &operation,
     std::function<Expr<RESULT>(Expr<OPERAND> &&)> &&f)
     -> std::optional<Expr<RESULT>> {
   auto &expr{operation.left()};
   expr = Fold(context, std::move(expr));
   if (expr.Rank() > 0) {
     if (std::optional<Shape> shape{GetShape(context, expr)}) {
       if (auto values{AsFlatArrayConstructor(expr)}) {
-        return MapOperation(context, std::move(f), *shape, std::move(*values));
+        return MapOperation(context, std::move(f), *shape,
+            ComputeResultLength(operation), std::move(*values));
       }
     }
   }
   return std::nullopt;
 }
 
 template <typename DERIVED, typename RESULT, typename OPERAND>
 auto ApplyElementwise(

flang/test/Evaluate/folding31.f90

+! RUN: %python %S/test_folding.py %s %flang_fc1
+! Test folding of character array conversion.
+module m
+  character(*,4), parameter :: str4arr(1) = ['a']
+  logical, parameter :: test = str4arr(1) == 4_'a'
+end