[flang][hlfir] Moved TODO for polymorphic vector subscripted expressions.

[vzakhari]

Summary

If I understand it correctly, the TODO is intended to catch cases
when we may need to create a temporary array for polymorphic entities
resulting from a vector subscription, i.e. when the final expression
type of hlfir.elemental_addr is polymorphic. The TODO check was done
very early, so it kicked in for cases where the it should not have.
For example,

type t
  integer n
end type
class(t), pointer :: p(:)
... p(vector_of_indices)%n

Such designators are supported by FIR lowering and can be currently
supported by HLFIR, but the TODO prevented this. I just moved the TODO
check later in the lowering pipeline.

I also updated the comment trying to describe my understanding of how
the correct mold entity can be computed for the elemental operation
producing HLFIR expression of polymorphic type.

This change provides 34 new passes in my nag testing.

[tblah]

LGTM but please wait for Jean to have a look too

[vzakhari]

Thank you for the review, Tom! I would like to merge this now. I will discuss it with Jean whenever he is available :)

[jeanPerier]

Sorry for the delay, this looks good to me.

Regarding the comment, I do not think one needs to evaluate an element to get the mold (although that may be a solution). If a vector subscripted designator is polymorphic, its dynamic type comes from the array part that is being vector subscripted (the partInfo.base near the previous TODO), the array should be usable directly as a mold for the dynamic type. In other words, there cannot be a polymorphic component after a vector subscript.
Rational:

• components can only be polymorphic if they are pointers/allocatable (F2018 C708)
• it is forbidden to have a ranked array part on the left of a pointer/allocatable component (F2018 C919)
• vector subscripted parts are ranked parts

-> The vector subscript must be on the right of the "polymorphic part"

So if the vector subscripted designator is polymorphic, the dynamic type is the same as the part that is vector subscripted (partInfo.base). However, as shown by your patch, partInfo.base being polymorphic does not imply that the resulting designator is polymorphic.

[vzakhari]

Thank you for the explanation, Jean! It helps a lot!

flang/lib/Lower/ConvertExprToHLFIR.cpp

private:
   /// be turned into an hlfir.elemental value, unless the caller of this
   /// utility requested to get the hlfir.elemental_addr instead of lowering
   /// the designator to an mlir::Value.
   mlir::Type createVectorSubscriptElementAddrOp(
       PartInfo &partInfo, mlir::Type baseType,
       llvm::ArrayRef<mlir::Value> resultExtents) {
     fir::FirOpBuilder &builder = getBuilder();
     mlir::Value shape = builder.genShape(loc, resultExtents);
-    // For polymorphic entities, it will be needed to add a mold on the
-    // hlfir.elemental_addr/hlfir.elemental so that we are able to create
-    // temporary storage for it.
-    if (partInfo.base && partInfo.base->isPolymorphic())
-      TODO(loc, "vector subscripted polymorphic entity in HLFIR");
     // The type parameters to be added on the hlfir.elemental_addr are the ones
     // of the whole designator (not the ones of the vector subscripted part).
     // These are not yet known and will be added when finalizing the designator
     // lowering.
     auto elementalAddrOp =
         builder.create<hlfir::ElementalAddrOp>(loc, shape,
                                                /*isUnordered=*/true);
     setVectorSubscriptElementAddrOp(elementalAddrOp);
private:
   }
 
   /// Yield the designator for the final part-ref inside the
   /// hlfir.elemental_addr.
   void finalizeElementAddrOp(hlfir::ElementalAddrOp elementalAddrOp,
                              hlfir::EntityWithAttributes elementAddr) {
     fir::FirOpBuilder &builder = getBuilder();
     builder.setInsertionPointToEnd(&elementalAddrOp.getBody().front());
+    // For polymorphic entities, it will be needed to add a mold on the
+    // hlfir.elemental so that we are able to create temporary storage
+    // for it using the dynamic type. It seems that a reference to the mold
+    // entity can be created by evaluating the hlfir.elemental_addr
+    // for a single index. The evaluation should be legal as long as
+    // the hlfir.elemental_addr has no side effects, otherwise,
+    // it is not clear how to get the mold reference.
+    if (elementAddr.isPolymorphic())
+      TODO(loc, "vector subscripted polymorphic entity in HLFIR");
     builder.create<hlfir::YieldOp>(loc, elementAddr);
     builder.setInsertionPointAfter(elementalAddrOp);
   }
 
   /// If the lowered designator has vector subscripts turn it into an
   /// ElementalOp, otherwise, return the lowered designator. This should
   /// only be called if the user did not request to get the
   /// hlfir.elemental_addr. In Fortran, vector subscripted designators are only

flang/test/Lower/HLFIR/designators-component-ref.f90

 ! Test lowering of component reference to HLFIR
-! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir --polymorphic-type -o - %s | FileCheck %s
 module comp_ref
 type t1
   integer :: scalar_i
   real :: scalar_x
 end type
 
 type t2
   integer :: scalar_i2

 ! CHECK:           %[[VAL_25:.*]] = arith.subi %[[VAL_17]], %[[VAL_10]] : index
 ! CHECK:           %[[VAL_26:.*]] = arith.addi %[[VAL_25]], %[[VAL_12]] : index
 ! CHECK:           %[[VAL_27:.*]] = arith.divsi %[[VAL_26]], %[[VAL_12]] : index
 ! CHECK:           %[[VAL_28:.*]] = arith.cmpi sgt, %[[VAL_27]], %[[VAL_24]] : index
 ! CHECK:           %[[VAL_29:.*]] = arith.select %[[VAL_28]], %[[VAL_27]], %[[VAL_24]] : index
 ! CHECK:           %[[VAL_30:.*]] = fir.shape %[[VAL_23]], %[[VAL_29]] : (index, index) -> !fir.shape<2>
 ! CHECK:           %[[VAL_31:.*]] = hlfir.designate %[[VAL_1]]#0{"array_comp"} <%[[VAL_11]]> (%[[VAL_9]]:%[[VAL_15]]:%[[VAL_12]], %[[VAL_10]]:%[[VAL_17]]:%[[VAL_12]]) imag shape %[[VAL_30]] : (!fir.ref<!fir.type<_QMcomp_refTt_complex{array_comp:!fir.array<10x20x!fir.complex<4>>}>>, !fir.shapeshift<2>, index, index, index, index, index, index, !fir.shape<2>) -> !fir.box<!fir.array<10x20xf32>>
 end subroutine
+
+subroutine test_poly_array_vector_subscript(p, v, r)
+  use comp_ref
+  class(t1),pointer :: p(:)
+  integer v(3)
+  integer r(3)
+  r = p(v)%scalar_i
+end subroutine test_poly_array_vector_subscript
+! CHECK-LABEL:   func.func @_QPtest_poly_array_vector_subscript(
+! CHECK-SAME:      %[[VAL_0:.*]]: !fir.ref<!fir.class<!fir.ptr<!fir.array<?x!fir.type<_QMcomp_refTt1{scalar_i:i32,scalar_x:f32}>>>>> {fir.bindc_name = "p"},
+! CHECK-SAME:      %[[VAL_1:.*]]: !fir.ref<!fir.array<3xi32>> {fir.bindc_name = "v"},
+! CHECK-SAME:      %[[VAL_2:.*]]: !fir.ref<!fir.array<3xi32>> {fir.bindc_name = "r"}) {
+! CHECK:           %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_0]] {fortran_attrs = #fir.var_attrs<pointer>, uniq_name = "_QFtest_poly_array_vector_subscriptEp"} : (!fir.ref<!fir.class<!fir.ptr<!fir.array<?x!fir.type<_QMcomp_refTt1{scalar_i:i32,scalar_x:f32}>>>>>) -> (!fir.ref<!fir.class<!fir.ptr<!fir.array<?x!fir.type<_QMcomp_refTt1{scalar_i:i32,scalar_x:f32}>>>>>, !fir.ref<!fir.class<!fir.ptr<!fir.array<?x!fir.type<_QMcomp_refTt1{scalar_i:i32,scalar_x:f32}>>>>>)
+! CHECK:           %[[VAL_4:.*]] = arith.constant 3 : index
+! CHECK:           %[[VAL_5:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1>
+! CHECK:           %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_2]](%[[VAL_5]]) {uniq_name = "_QFtest_poly_array_vector_subscriptEr"} : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> (!fir.ref<!fir.array<3xi32>>, !fir.ref<!fir.array<3xi32>>)
+! CHECK:           %[[VAL_7:.*]] = arith.constant 3 : index
+! CHECK:           %[[VAL_8:.*]] = fir.shape %[[VAL_7]] : (index) -> !fir.shape<1>
+! CHECK:           %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_8]]) {uniq_name = "_QFtest_poly_array_vector_subscriptEv"} : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> (!fir.ref<!fir.array<3xi32>>, !fir.ref<!fir.array<3xi32>>)
+! CHECK:           %[[VAL_10:.*]] = fir.load %[[VAL_3]]#0 : !fir.ref<!fir.class<!fir.ptr<!fir.array<?x!fir.type<_QMcomp_refTt1{scalar_i:i32,scalar_x:f32}>>>>>
+! CHECK:           %[[VAL_11:.*]] = hlfir.elemental %[[VAL_8]] unordered : (!fir.shape<1>) -> !hlfir.expr<3xi64> {
+! CHECK:           ^bb0(%[[VAL_12:.*]]: index):
+! CHECK:             %[[VAL_13:.*]] = hlfir.designate %[[VAL_9]]#0 (%[[VAL_12]])  : (!fir.ref<!fir.array<3xi32>>, index) -> !fir.ref<i32>
+! CHECK:             %[[VAL_14:.*]] = fir.load %[[VAL_13]] : !fir.ref<i32>
+! CHECK:             %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (i32) -> i64
+! CHECK:             hlfir.yield_element %[[VAL_15]] : i64
+! CHECK:           }
+! CHECK:           %[[VAL_16:.*]] = arith.constant 3 : index
+! CHECK:           %[[VAL_17:.*]] = fir.shape %[[VAL_16]] : (index) -> !fir.shape<1>
+! CHECK:           %[[VAL_18:.*]] = hlfir.elemental %[[VAL_17]] unordered : (!fir.shape<1>) -> !hlfir.expr<3xi32> {
+! CHECK:           ^bb0(%[[VAL_19:.*]]: index):
+! CHECK:             %[[VAL_20:.*]] = hlfir.apply %[[VAL_11]], %[[VAL_19]] : (!hlfir.expr<3xi64>, index) -> i64
+! CHECK:             %[[VAL_21:.*]] = hlfir.designate %[[VAL_10]] (%[[VAL_20]])  : (!fir.class<!fir.ptr<!fir.array<?x!fir.type<_QMcomp_refTt1{scalar_i:i32,scalar_x:f32}>>>>, i64) -> !fir.class<!fir.type<_QMcomp_refTt1{scalar_i:i32,scalar_x:f32}>>
+! CHECK:             %[[VAL_22:.*]] = hlfir.designate %[[VAL_21]]{"scalar_i"}   : (!fir.class<!fir.type<_QMcomp_refTt1{scalar_i:i32,scalar_x:f32}>>) -> !fir.ref<i32>
+! CHECK:             %[[VAL_23:.*]] = fir.load %[[VAL_22]] : !fir.ref<i32>
+! CHECK:             hlfir.yield_element %[[VAL_23]] : i32
+! CHECK:           }
+! CHECK:           hlfir.assign %[[VAL_18]] to %[[VAL_6]]#0 : !hlfir.expr<3xi32>, !fir.ref<!fir.array<3xi32>>
+! CHECK:           hlfir.destroy %[[VAL_18]] : !hlfir.expr<3xi32>
+! CHECK:           hlfir.destroy %[[VAL_11]] : !hlfir.expr<3xi64>
+! CHECK:           return
+! CHECK:         }