[flang] Fix ORDER= argument to RESHAPE

[klausler]

Summary

The ORDER= argument to the transformational intrinsic function RESHAPE
was being misinterpreted in an inverted way that could be detected only
with 3-d or higher rank array. Fix in both folding and the runtime, and
extend tests.

[jeanPerier]

Looks good.

flang/include/flang/Evaluate/constant.h

 inline int GetRank(const ConstantSubscripts &s) {
   return static_cast<int>(s.size());
 }
 
 std::size_t TotalElementCount(const ConstantSubscripts &);
 
 // Validate dimension re-ordering like ORDER in RESHAPE.
 // On success, return a vector that can be used as dimOrder in
-// ConstantBound::IncrementSubscripts().
+// ConstantBounds::IncrementSubscripts().
 std::optional<std::vector<int>> ValidateDimensionOrder(
     int rank, const std::vector<int> &order);
 
 bool HasNegativeExtent(const ConstantSubscripts &);
 
 class ConstantBounds {
 public:
   ConstantBounds() = default;

flang/lib/Evaluate/constant.cpp

std::optional<std::vector<int>> ValidateDimensionOrder(
   std::vector<int> dimOrder(rank);
   if (static_cast<int>(order.size()) == rank) {
     std::bitset<common::maxRank> seenDimensions;
     for (int j{0}; j < rank; ++j) {
       int dim{order[j]};
       if (dim < 1 || dim > rank || seenDimensions.test(dim - 1)) {
         return std::nullopt;
       }
-      dimOrder[dim - 1] = j;
+      dimOrder[j] = dim - 1;
       seenDimensions.set(dim - 1);
     }
     return dimOrder;
   } else {
     return std::nullopt;
   }
 }
 

flang/runtime/transformational.cpp

if (order) {
     SubscriptValue orderSubscript{order->GetDimension(0).LowerBound()};
     std::size_t orderElementBytes{order->ElementBytes()};
     for (SubscriptValue j{0}; j < resultRank; ++j, ++orderSubscript) {
       auto k{GetInt64(order->Element<char>(&orderSubscript), orderElementBytes,
           terminator)};
       RUNTIME_CHECK(
           terminator, k >= 1 && k <= resultRank && !((values >> k) & 1));
       values |= std::uint64_t{1} << k;
-      dimOrder[k - 1] = j;
+      dimOrder[j] = k - 1;
     }
   } else {
     for (int j{0}; j < resultRank; ++j) {
       dimOrder[j] = j;
     }
   }
 
   // Allocate result descriptor

flang/test/Evaluate/folding06.f90

reshape([a::a(x=1.5_4,i=1_8),a(x=5.5_4,i=5_8),a(x=2.5_4,i=2_8), a(x=6.5_4,i=6_8), &
       a(x=3.5_4,i=3_8),a(x=7.5_4,i=7_8),a(x=4.5_4,i=4_8),a(x=8.5_4,i=8_8)], new_shape)
 
   type(A), parameter :: derived_result(*, *) = reshape(derived_source, new_shape, derived_pad, order)
 
   logical, parameter :: test_reshape_derived_1 = all((derived_result%x.EQ.derived_expected_result%x) &
       .AND.(derived_result%i.EQ.derived_expected_result%i))
 
   logical, parameter :: test_reshape_derived_2 = all(shape(derived_result).EQ.new_shape)
+
+  ! More complicated ORDER= arguments
+  integer, parameter :: int3d(2,3,4) = reshape([(j,j=1,24)],shape(int3d))
+  logical, parameter :: test_int3d = all([int3d] == [(j,j=1,24)])
+  logical, parameter :: test_reshape_order_1 = all([reshape(int3d, [2,3,4], order=[1,2,3])] == [(j,j=1,24)])
+  logical, parameter :: test_reshape_order_2 = all([reshape(int3d, [2,4,3], order=[1,3,2])] == [1,2,7,8,13,14,19,20,3,4,9,10,15,16,21,22,5,6,11,12,17,18,23,24])
+  logical, parameter :: test_reshape_order_3 = all([reshape(int3d, [3,2,4], order=[2,1,3])] == [1,3,5,2,4,6,7,9,11,8,10,12,13,15,17,14,16,18,19,21,23,20,22,24])
+  logical, parameter :: test_reshape_order_4 = all([reshape(int3d, [3,4,2], order=[2,3,1])] == [1,9,17,2,10,18,3,11,19,4,12,20,5,13,21,6,14,22,7,15,23,8,16,24])
+  logical, parameter :: test_reshape_order_5 = all([reshape(int3d, [4,2,3], order=[3,1,2])] == [1,4,7,10,13,16,19,22,2,5,8,11,14,17,20,23,3,6,9,12,15,18,21,24])
+  logical, parameter :: test_reshape_order_6 = all([reshape(int3d, [4,3,2], order=[3,2,1])] == [1,7,13,19,3,9,15,21,5,11,17,23,2,8,14,20,4,10,16,22,6,12,18,24])
+
 end module