[flang] Handle missing substring upper bound better when folding

[klausler]

Summary

When folding a substring of a named constant or character literal,
acquire the value of a missing upper bound from the base object.

[vzakhari]

LGTM. Thanks!

flang/lib/Evaluate/variable.cpp

 static std::optional<Expr<SubscriptInteger>> SymbolLEN(const Symbol &symbol) {
   const Symbol &ultimate{symbol.GetUltimate()};
   if (const auto *assoc{ultimate.detailsIf<semantics::AssocEntityDetails>()}) {
     if (const auto *chExpr{UnwrapExpr<Expr<SomeCharacter>>(assoc->expr())}) {
       return chExpr->LEN();
     }
   }
   if (auto dyType{DynamicType::From(ultimate)}) {
-    if (auto len{dyType->GetCharLength()}) {
+    auto len{dyType->GetCharLength()};
+    if (!len && ultimate.attrs().test(semantics::Attr::PARAMETER)) {
+      // Its initializer determines the length of an implied-length named
+      // constant.
+      if (const auto *object{
+              ultimate.detailsIf<semantics::ObjectEntityDetails>()}) {
+        if (object->init()) {
+          if (auto dyType2{DynamicType::From(*object->init())}) {
+            len = dyType2->GetCharLength();
+          }
+        }
+      }
+    }
+    if (len) {
       if (auto constLen{ToInt64(*len)}) {
         return Expr<SubscriptInteger>{std::max<std::int64_t>(*constLen, 0)};
       } else if (ultimate.owner().IsDerivedType() ||
           IsScopeInvariantExpr(*len)) {
         return AsExpr(Extremum<SubscriptInteger>{
             Ordering::Greater, Expr<SubscriptInteger>{0}, std::move(*len)});
       }
     }

flang/test/Evaluate/fold-substr.f90

 ! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Test folding of substrings
 module m
   logical, parameter :: test_01a = "abc"(1:3) == "abc"
   logical, parameter :: test_01b = len("abc"(1:3)) == 3
   logical, parameter :: test_02a = "abc"(-1:-2) == ""
   logical, parameter :: test_02b = len("abc"(-1:-2)) == 0
   logical, parameter :: test_03a = "abc"(9999:4) == ""
   logical, parameter :: test_03b = len("abc"(9999:4)) == 0
   character(4), parameter :: ca(3) = ["abcd", "efgh", "ijkl"]
   logical, parameter :: test_04a = ca(2)(2:4) == "fgh"
   logical, parameter :: test_04b = len(ca(2)(2:4)) == 3
   logical, parameter :: test_05a = all(ca(:)(2:4) == ["bcd", "fgh", "jkl"])
   logical, parameter :: test_05b = len(ca(:)(2:4)) == 3
   logical, parameter :: test_06a = ca(1)(1:2)//ca(2)(2:3)//ca(3)(3:4) == "abfgkl"
   logical, parameter :: test_06b = len(ca(1)(1:2)//ca(2)(2:3)//ca(3)(3:4)) == 6
+  logical, parameter :: test_07a = ca(1)(:2) == "ab"
+  logical, parameter :: test_07b = ca(1)(3:) == "cd"
+  logical, parameter :: test_07c = ca(1)(:-1) == ""
+  logical, parameter :: test_07d = ca(1)(5:) == ""
+  logical, parameter :: test_07e = ca(1)(:) == "abcd"
 end module

flang/test/Lower/character-local-variables.f90

subroutine dyn_array_dyn_len_lb(l, n)
   ! CHECK: fir.alloca !fir.array<?x!fir.char<1,?>>(%[[l]] : i64), %[[extent]] {{{.*}}uniq_name = "_QFdyn_array_dyn_len_lbEc"}
 end subroutine
 
 ! Test that the length of assumed length parameter is correctly deduced in lowering.
 ! CHECK-LABEL: func @_QPassumed_length_param
 subroutine assumed_length_param(n)
   character(*), parameter :: c(1)=(/"abcd"/)
   integer :: n
-  ! CHECK: %[[c4:.*]] = arith.constant 4 : index
-  ! CHECK: %[[len:.*]] = fir.convert %[[c4]] : (index) -> i64
-  ! CHECK: fir.store %[[len]] to %[[tmp:.*]] : !fir.ref<i64>
+  ! CHECK: %[[c4:.*]] = arith.constant 4 : i64
+  ! CHECK: fir.store %[[c4]] to %[[tmp:.*]] : !fir.ref<i64>
   ! CHECK: fir.call @_QPtake_int(%[[tmp]]) {{.*}}: (!fir.ref<i64>) -> ()
   call take_int(len(c(n), kind=8))
 end
 
 ! CHECK-LABEL: func @_QPscalar_cst_neg_len
 subroutine scalar_cst_neg_len()
   character(-1) :: c
   ! CHECK: fir.alloca !fir.char<1,0> {{{.*}}uniq_name = "_QFscalar_cst_neg_lenEc"}
 end subroutine