[flang] Handle empty array references in DATA statements

[klausler]

Summary

When an array reference in a DATA statement is empty due to an
empty vector subscript or a section lower bound being higher than
its upper bound with a positive stride (or lower with negative),
ensure that isEmpty() is correct afterwards so that such an empty
array reference doesn't terminate processing of that DATA statement
block.

Fixes https://github.com/llvm/llvm-project/issues/63512.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Evaluate/fold-designator.cpp

if (auto extents{GetConstantExtents(context_, array)}) {
                               ConstantSubscript at{
                                   value->values().at(remainder).ToInt64()};
                               if (at < lower || at > upper) {
                                 isOutOfRange_ = true;
                               }
                               result->Augment((at - lower) * stride);
                               which = quotient;
                               return true;
+                            } else {
+                              isEmpty_ = true;
                             }
                           }
                           return false;
                         },
                         [&](const Triplet &triplet) {
                           auto start{ToInt64(Fold(context_,
                               triplet.lower().value_or(ExtentExpr{lower})))};
                           auto end{ToInt64(Fold(context_,
                               triplet.upper().value_or(ExtentExpr{upper})))};
                           auto step{ToInt64(Fold(context_, triplet.stride()))};
-                          if (start && end && step && *step != 0) {
+                          if (start && end && step) {
+                            if (*step != 0) {
                               ConstantSubscript range{
                                   (*end - *start + *step) / *step};
                               if (range > 0) {
                                 auto quotient{which / range};
                                 auto remainder{which - range * quotient};
                                 auto j{*start + remainder * *step};
                                 result->Augment((j - lower) * stride);
                                 which = quotient;
                                 return true;
+                              } else {
+                                isEmpty_ = true;
+                              }
                             }
                           }
                           return false;
                         },
                     },
                     subscript.u)) {
               return std::nullopt;
             }

flang/test/Semantics/data05.f90

subroutine s11
     type(t1) :: d5 ! CHECK: d5 (InDataStmt) size=136 offset=592: ObjectEntity type: TYPE(t1(kind=4_1,len=1_2)) init:t1(kind=4_1,len=1_2)(j=1_4,x=reshape([REAL(4)::1._4,2._4,3._4,4._4],shape=[2,2]),z=(6._4,7._4),t=.false._4,c=[CHARACTER(KIND=1,LEN=1)::"a","b"],xp=arr,ifptr=ifunc2,rp=rfunc,xrp=extrfunc)
     data d5%j/1/,d5%x/1,2,3,4/,d5%z%re/6./,d5%z%im/7./,d5%t/.false./,d5%c(1:1)/'a'/,d5%c(2:&
       &2)/'b'/,d5%xp/arr/,d5%ifptr/ifunc2/,d5%rp/rfunc/,d5%xrp/extrfunc/
   end subroutine
   subroutine s12
     procedure(rfunc), pointer :: pp ! CHECK: pp, EXTERNAL, POINTER (Function, InDataStmt) size=8 offset=0: ProcEntity rfunc => rfunc2
     data pp/rfunc2/
   end subroutine
+  subroutine s13
+    integer j(2)
+    data j(2:1), j(1:2) /1,2/ ! CHECK: j (InDataStmt) size=8 offset=0: ObjectEntity type: INTEGER(4) shape: 1_8:2_8 init:[INTEGER(4)::1_4,2_4]
+  end subroutine
 end module