[flang] Fix LBOUND rewrite on descriptor components

[jeanPerier]

Summary

GetLowerBoundHelper rewrite in https://reviews.llvm.org/D121488 was
incorrect with POINTER/ALLOCATABLE components. The rewrite created a
descriptor inquiry to the component symbol only instead of the whole
named entity. The base information was lost, and not retrievable.
LBOUND(a(10)%p) became LBOUND(p).

Fix this regression, and also update DescriptorInquiry unparsing to
carry the kind information. DescriptorInquiries are KIND 8 expressions,
while LBOUND/SIZE/RANK, %LEN are default kind expressions.
This caused print *,lbound(x,kind=8) to unparse as print*,lbound(x) which is not
semantically the same (this unparsing issue was not an issue for
lowering, but I noticed it while writing my regression test).

flang/lib/Evaluate/formatting.cpp

case Field::LowerBound:
     break;
   case Field::Extent:
     o << "size(";
     break;
   case Field::Stride:
     o << "%STRIDE(";
     break;
   case Field::Rank:
-    o << "rank(";
+    o << "int(rank(";
     break;
   case Field::Len:
+    o << "int(";
     break;
   }
   base_.AsFortran(o);
   if (field_ == Field::Len) {
-    return o << "%len";
+    o << "%len";
+  } else if (field_ == Field::Rank) {
+    o << ")";
   } else {
-    if (field_ != Field::Rank && dimension_ >= 0) {
+    if (dimension_ >= 0) {
       o << ",dim=" << (dimension_ + 1);
     }
-    return o << ')';
   }
+  return o << ",kind=" << DescriptorInquiry::Result::kind << ")";
 }
 
 llvm::raw_ostream &Assignment::AsFortran(llvm::raw_ostream &o) const {
   std::visit(
       common::visitors{
           [&](const Assignment::Intrinsic &) {
             rhs.AsFortran(lhs.AsFortran(o) << '=');
           },

flang/lib/Evaluate/shape.cpp

public:
   explicit GetLowerBoundHelper(int d, FoldingContext *context)
       : Base{*this}, dimension_{d}, context_{context} {}
   static Result Default() { return Result{1}; }
   static Result Combine(Result &&, Result &&) {
     // Operator results and array references always have lower bounds == 1
     return Result{1};
   }
 
-  Result operator()(const Symbol &symbol0) const {
+  Result GetLowerBound(const Symbol &symbol0, NamedEntity &&base) const {
     const Symbol &symbol{symbol0.GetUltimate()};
     if (const auto *details{
             symbol.detailsIf<semantics::ObjectEntityDetails>()}) {
       int rank{details->shape().Rank()};
       if (dimension_ < rank) {
         const semantics::ShapeSpec &shapeSpec{details->shape()[dimension_]};
         if (shapeSpec.lbound().isExplicit()) {
           if (const auto &lbound{shapeSpec.lbound().GetExplicit()}) {
if (const auto *details{
             } else {
               return *lbound;
             }
           } else {
             return Result{1};
           }
         }
         if (IsDescriptor(symbol)) {
-          return ExtentExpr{DescriptorInquiry{NamedEntity{symbol0},
+          return ExtentExpr{DescriptorInquiry{std::move(base),
               DescriptorInquiry::Field::LowerBound, dimension_}};
         }
       }
     } else if (const auto *assoc{
                    symbol.detailsIf<semantics::AssocEntityDetails>()}) {
       if (assoc->rank()) { // SELECT RANK case
         const Symbol &resolved{ResolveAssociations(symbol)};
         if (IsDescriptor(resolved) && dimension_ < *assoc->rank()) {
-          return ExtentExpr{DescriptorInquiry{NamedEntity{symbol0},
+          return ExtentExpr{DescriptorInquiry{std::move(base),
               DescriptorInquiry::Field::LowerBound, dimension_}};
         }
       } else {
         return (*this)(assoc->expr());
       }
     }
     if constexpr (LBOUND_SEMANTICS) {
       return Result{};
     } else {
       return Result{1};
     }
   }
 
+  Result operator()(const Symbol &symbol0) const {
+    return GetLowerBound(symbol0, NamedEntity{symbol0});
+  }
+
   Result operator()(const Component &component) const {
     if (component.base().Rank() == 0) {
-      return (*this)(component.GetLastSymbol());
+      return GetLowerBound(
+          component.GetLastSymbol(), NamedEntity{common::Clone(component)});
     }
     return Result{1};
   }
 
 private:
   int dimension_;
   FoldingContext *context_{nullptr};
 };

flang/test/Evaluate/rewrite01.f90

 function returns_array_3()
   integer :: returns_array_3(7:46+2)
   returns_array_3 = 0
 end function
 
 subroutine ubound_test(x, n, m)
   integer :: x(n, m)
   integer :: y(0:n, 0:m) ! UBOUND could be 0 if n or m are < 0
-  !CHECK: PRINT *, [INTEGER(4)::int(size(x,dim=1),kind=4),int(size(x,dim=2),kind=4)]
+  !CHECK: PRINT *, [INTEGER(4)::int(size(x,dim=1,kind=8),kind=4),int(size(x,dim=2,kind=8),kind=4)]
   print *, ubound(x)
   !CHECK: PRINT *, ubound(returns_array(n,m))
   print *, ubound(returns_array(n, m))
   !CHECK: PRINT *, ubound(returns_array(n,m),dim=1_4)
   print *, ubound(returns_array(n, m), dim=1)
   !CHECK: PRINT *, ubound(returns_array_2(m))
   print *, ubound(returns_array_2(m))
   !CHECK: PRINT *, 42_8
   print *, ubound(returns_array_3(), dim=1, kind=8)
   !CHECK: PRINT *, ubound(y)
   print *, ubound(y)
   !CHECK: PRINT *, ubound(y,1_4)
   print *, ubound(y, 1)
 end subroutine
 
 subroutine size_test(x, n, m)
   integer :: x(n, m)
-  !CHECK: PRINT *, int(size(x,dim=1)*size(x,dim=2),kind=4)
+  !CHECK: PRINT *, int(size(x,dim=1,kind=8)*size(x,dim=2,kind=8),kind=4)
   print *, size(x)
   !CHECK: PRINT *, size(returns_array(n,m))
   print *, size(returns_array(n, m))
   !CHECK: PRINT *, size(returns_array(n,m),dim=1_4)
   print *, size(returns_array(n, m), dim=1)
   !CHECK: PRINT *, size(returns_array_2(m))
   print *, size(returns_array_2(m))
   !CHECK: PRINT *, 42_8
   print *, size(returns_array_3(), kind=8)
 end subroutine
 
 subroutine shape_test(x, n, m)
   integer :: x(n, m)
-  !CHECK: PRINT *, [INTEGER(4)::int(size(x,dim=1),kind=4),int(size(x,dim=2),kind=4)]
+  !CHECK: PRINT *, [INTEGER(4)::int(size(x,dim=1,kind=8),kind=4),int(size(x,dim=2,kind=8),kind=4)]
   print *, shape(x)
   !CHECK: PRINT *, shape(returns_array(n,m))
   print *, shape(returns_array(n, m))
   !CHECK: PRINT *, shape(returns_array_2(m))
   print *, shape(returns_array_2(m))
   !CHECK: PRINT *, [INTEGER(8)::42_8]
   print *, shape(returns_array_3(), kind=8)
 end subroutine
 
 subroutine lbound_test(x, n, m)
   integer :: x(n, m)
   integer :: y(0:n, 0:m) ! LBOUND could be 1 if n or m are < 0
+  type t
+    real, pointer :: p(:, :)
+  end type
+  type(t) :: a(10)
   !CHECK: PRINT *, [INTEGER(4)::1_4,1_4]
   print *, lbound(x)
   !CHECK: PRINT *, [INTEGER(4)::1_4,1_4]
   print *, lbound(returns_array(n, m))
   !CHECK: PRINT *, 1_4
   print *, lbound(returns_array(n, m), dim=1)
   !CHECK: PRINT *, 1_4
   print *, lbound(returns_array_2(m), dim=1)
   !CHECK: PRINT *, 1_4
   print *, lbound(returns_array_3(), dim=1)
   !CHECK: PRINT *, lbound(y)
   print *, lbound(y)
   !CHECK: PRINT *, lbound(y,1_4)
   print *, lbound(y, 1)
+  !CHECK: PRINT *, lbound(a(1_8)%p,dim=1,kind=8)
+  print *, lbound(a(1)%p, 1, kind=8)
 end subroutine
 
 !CHECK: len_test
 subroutine len_test(a,b, c, d, e, n, m)
   character(*), intent(in) :: a
   character(*) :: b
   external b
   character(10), intent(in) :: c
   character(10) :: d
   external d
   integer, intent(in) :: n, m
   character(n), intent(in) :: e
 
-  !CHECK: PRINT *, int(a%len,kind=4)
-  print *, len(a)
+  !CHECK: PRINT *, int(a%len,kind=8)
+  print *, len(a, kind=8)
   !CHECK: PRINT *, 5_4
   print *, len(a(1:5))
   !CHECK: PRINT *, len(b(a))
   print *, len(b(a))
   !CHECK: PRINT *, len(b(a)//a)
   print *, len(b(a) // a)
   !CHECK: PRINT *, 10_4
   print *, len(c)

flang/test/Semantics/modfile30.f90

contains
   end
 end
 
 !Expect: m1.mod
 !module m1
 !contains
 ! function f1(x) result(y)
 !  integer(4)::x(:)
-!  integer(4)::y(1_8:size(x,dim=1))
+!  integer(4)::y(1_8:size(x,dim=1,kind=8))
 ! end
 ! function f2(x)
 !  integer(4)::x(:)
-!  integer(4)::f2(1_8:size(x,dim=1))
+!  integer(4)::f2(1_8:size(x,dim=1,kind=8))
 ! end
 !end
 
 ! Order of names in PUBLIC statement shouldn't affect .mod file.
 module m2
   public :: a
   type t
   end type

flang/test/Semantics/modfile33.f90

 !  end
 ! end interface
 !contains
 ! subroutine s1(n, x, y, z, a, b)
 !  integer(8) :: n
 !  real(4) :: x
 !  real(4) :: y(1_8:4_8, 1_8:n)
 !  real(4) :: z(1_8:2_8, 1_8:2_8, 1_8:2_8)
-!  real(4) :: a(1_8:int(int(4_8*size(y,dim=2),kind=4),kind=8))
+!  real(4) :: a(1_8:int(int(4_8*size(y,dim=2,kind=8),kind=4),kind=8))
 !  real(4) :: b(1_8:add(y, z))
 ! end
 !end
 
 ! Parameterized derived type
 module m7
   type :: t(k)
     integer, kind :: k