[flang] Fix an assert when RESHAPE() is called on empty strings

[PeteSteinfeld]

Summary

When a constant array of empty strings goes through contant folding, the result
is something that contains no bytes. If this array is passed to the intrinsic
function RESHAPE(), we were not handling things correctly. I fixed this by
checking for an empty destination when calling the function CopyFrom() on an
array of strings.

I also added a test with a couple of different examples that trigger the
problem.

[klausler]

flang/lib/Evaluate/constant.cpp

257

This new 'if' statement might just hide bugs. Can copied be >= values_.size() and still be valid?

[PeteSteinfeld]

flang/lib/Evaluate/constant.cpp

257

Oops. This if is a left-over from an earlier attempt to fix this problem. It's unnecessary now, and I'll remove it.

[PeteSteinfeld]

Removed an unnecessary if condition.

flang/lib/Evaluate/constant.cpp

 }
 
 template <int KIND>
 std::size_t Constant<Type<TypeCategory::Character, KIND>>::CopyFrom(
     const Constant<Type<TypeCategory::Character, KIND>> &source,
     std::size_t count, ConstantSubscripts &resultSubscripts,
     const std::vector<int> *dimOrder) {
   CHECK(length_ == source.length_);
+  if (length_ == 0) {
+    // It's possible that the array of strings consists of all empty strings.
+    // If so, constant folding will result in a string that's completely empty
+    // and the length_ will be zero, and there's nothing to do.
+    return count;
+  } else {
     std::size_t copied{0};
     std::size_t elementBytes{length_ * sizeof(decltype(values_[0]))};
     ConstantSubscripts sourceSubscripts{source.lbounds()};
     while (copied < count) {
       auto *dest{&values_.at(SubscriptsToOffset(resultSubscripts) * length_)};
       const auto *src{&source.values_.at(
           source.SubscriptsToOffset(sourceSubscripts) * length_)};
       std::memcpy(dest, src, elementBytes);
       copied++;
       source.IncrementSubscripts(sourceSubscripts);
       IncrementSubscripts(resultSubscripts, dimOrder);
     }
     return copied;
   }
+}
 
 // Constant<SomeDerived> specialization
 Constant<SomeDerived>::Constant(const StructureConstructor &x)
     : Base{x.values(), Result{x.derivedTypeSpec()}} {}
 
 Constant<SomeDerived>::Constant(StructureConstructor &&x)
     : Base{std::move(x.values()), Result{x.derivedTypeSpec()}} {}
 

flang/test/Semantics/modfile25.f90

module m1
   integer(8), parameter :: ac4s(*) = shape([((j,k,j*k,k=1,3),j=1,4)])
   integer(8), parameter :: ac5s(*) = shape([((0,k=5,1,-2),j=9,2,-3)])
   integer(8), parameter :: rss(*) = shape(reshape([(0,j=1,90)], -[2,3]*(-[5_8,3_8])))
  contains
   subroutine subr(x,n1,n2)
     real, intent(in) :: x(:,:)
     integer, intent(in) :: n1(3), n2(:)
     real, allocatable :: a(:,:,:)
+    ! the following fail if we don't handle empty strings
+    Character(0) :: ch1(1,2,3) = Reshape([('',n=1,1*2*3)],[1,2,3])
+    Character(0) :: ch2(3) = reshape(['','',''], [3])
     a = reshape(x,n1)
     a = reshape(x,n2(10:30:9)) ! fails if we can't figure out triplet shape
   end subroutine
 end module m1
 !Expect: m1.mod
 ! module m1
 ! integer(8),parameter::a0s(1_8:*)=[INTEGER(8)::]
 ! intrinsic::shape