[flang] Fix to IsDescriptor

[klausler]

Summary

IsDescriptor was returning false for a component whose shape depended
on a length parameter. Change it to return true for any array with
non-constant bounds.

flang/include/flang/Semantics/type.h

 //===-- include/flang/Semantics/type.h --------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
struct ArraySpec : public std::vector<ShapeSpec> {
   ArraySpec() {}
   int Rank() const { return size(); }
   bool IsExplicitShape() const;
   bool IsAssumedShape() const;
   bool IsDeferredShape() const;
   bool IsImpliedShape() const;
   bool IsAssumedSize() const;
   bool IsAssumedRank() const;
+  bool IsConstantShape() const; // explicit shape with constant bounds
 
 private:
   // Check non-empty and predicate is true for each element.
   template <typename P> bool CheckAll(P predicate) const {
     return !empty() && std::all_of(begin(), end(), predicate);
   }
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ArraySpec &);

flang/lib/Evaluate/type.cpp

 //===-- lib/Evaluate/type.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 

 static bool IsDescriptor(const ObjectEntityDetails &details) {
   if (const auto *type{details.type()}) {
     if (auto dynamicType{evaluate::DynamicType::From(*type)}) {
       if (dynamicType->RequiresDescriptor()) {
         return true;
       }
     }
   }
-  if (details.IsAssumedShape() || details.IsDeferredShape() ||
-      details.IsAssumedRank()) {
-    return true;
-  }
-  // TODO: Explicit shape component array dependent on length parameter
   // TODO: Automatic (adjustable) arrays - are they descriptors?
-  return false;
+  return !details.shape().empty() && !details.shape().IsConstantShape();
 }
 
 static bool IsDescriptor(const ProcEntityDetails &details) {
   // A procedure pointer or dummy procedure must be & is a descriptor if
   // and only if it requires a static link.
   // TODO: refine this placeholder
   return details.HasExplicitInterface();
 }

flang/lib/Semantics/type.cpp

 //===-- lib/Semantics/type.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 

 bool ArraySpec::IsAssumedSize() const {
   return !empty() && !IsAssumedRank() && back().ubound().isAssumed() &&
       std::all_of(begin(), end() - 1,
           [](const ShapeSpec &x) { return x.ubound().isExplicit(); });
 }
 bool ArraySpec::IsAssumedRank() const {
   return Rank() == 1 && front().lbound().isAssumed();
 }
+bool ArraySpec::IsConstantShape() const {
+  return CheckAll([](const ShapeSpec &x) {
+    const auto &lb{x.lbound().GetExplicit()};
+    const auto &ub{x.ubound().GetExplicit()};
+    return lb && ub && IsConstantExpr(*lb) && IsConstantExpr(*ub);
+  });
+}
 
 llvm::raw_ostream &operator<<(
     llvm::raw_ostream &os, const ArraySpec &arraySpec) {
   char sep{'('};
   for (auto &shape : arraySpec) {
     os << sep << shape;
     sep = ',';
   }

flang/test/Semantics/offsets01.f90

subroutine s5(n)
   end type
   type :: t2(l1, l2)
     integer, len :: l1
     integer, len :: l2
     real :: b(l1, l2)
   end type
   type(t1(n))   :: x1 !CHECK: x1 size=48 offset=
   type(t2(n,n)) :: x2 !CHECK: x2 size=56 offset=
+  !CHECK: a size=48 offset=0:
+  !CHECK: b size=72 offset=0:
 end