[flang] Plug error recovery hole for erroneous subscripts

[klausler]

Summary

Avoid a crash in folding an empty vector of subscripts
that resulted from a semantic error.

flang/lib/Semantics/expression.cpp

MaybeExpr ExpressionAnalyzer::Designate(DataRef &&ref) {
   }
   return std::nullopt;
 }
 
 // Some subscript semantic checks must be deferred until all of the
 // subscripts are in hand.
 MaybeExpr ExpressionAnalyzer::CompleteSubscripts(ArrayRef &&ref) {
   const Symbol &symbol{ref.GetLastSymbol().GetUltimate()};
-  const auto *object{symbol.detailsIf<semantics::ObjectEntityDetails>()};
   int symbolRank{symbol.Rank()};
   int subscripts{static_cast<int>(ref.size())};
   if (subscripts == 0) {
-    // nothing to check
+    return std::nullopt; // error recovery
   } else if (subscripts != symbolRank) {
     if (symbolRank != 0) {
       Say("Reference to rank-%d object '%s' has %d subscripts"_err_en_US,
           symbolRank, symbol.name(), subscripts);
     }
     return std::nullopt;
   } else if (Component * component{ref.base().UnwrapComponent()}) {
     int baseRank{component->base().Rank()};
     if (baseRank > 0) {
       int subscriptRank{0};
       for (const auto &expr : ref.subscript()) {
         subscriptRank += expr.Rank();
       }
       if (subscriptRank > 0) {
         Say("Subscripts of component '%s' of rank-%d derived type "
             "array have rank %d but must all be scalar"_err_en_US,
             symbol.name(), baseRank, subscriptRank);
         return std::nullopt;
       }
     }
-  } else if (object) {
+  } else if (const auto *object{
+                 symbol.detailsIf<semantics::ObjectEntityDetails>()}) {
     // C928 & C1002
     if (Triplet * last{std::get_if<Triplet>(&ref.subscript().back().u)}) {
       if (!last->upper() && object->IsAssumedSize()) {
         Say("Assumed-size array '%s' must have explicit final "
             "subscript upper bound value"_err_en_US,
             symbol.name());
         return std::nullopt;
       }
     }
+  } else {
+    // Shouldn't get here from Analyze(ArrayElement) without a valid base,
+    // which, if not an object, must be a construct entity from
+    // SELECT TYPE/RANK or ASSOCIATE.
+    CHECK(symbol.has<semantics::AssocEntityDetails>());
   }
   return Designate(DataRef{std::move(ref)});
 }
 
 // Applies subscripts to a data reference.
 MaybeExpr ExpressionAnalyzer::ApplySubscripts(
     DataRef &&dataRef, std::vector<Subscript> &&subscripts) {
+  if (subscripts.empty()) {
+    return std::nullopt; // error recovery
+  }
   return std::visit(
       common::visitors{
           [&](SymbolRef &&symbol) {
             return CompleteSubscripts(ArrayRef{symbol, std::move(subscripts)});
           },
           [&](Component &&c) {
             return CompleteSubscripts(
                 ArrayRef{std::move(c), std::move(subscripts)});
MaybeExpr ExpressionAnalyzer::Analyze(const parser::ArrayElement &ae) {
   MaybeExpr baseExpr;
   {
     auto restorer{AllowWholeAssumedSizeArray()};
     baseExpr = Analyze(ae.base);
   }
   if (baseExpr) {
     if (ae.subscripts.empty()) {
       // will be converted to function call later or error reported
-      return std::nullopt;
     } else if (baseExpr->Rank() == 0) {
       if (const Symbol * symbol{GetLastSymbol(*baseExpr)}) {
         if (!context_.HasError(symbol)) {
           Say("'%s' is not an array"_err_en_US, symbol->name());
           context_.SetError(*symbol);
         }
       }
     } else if (std::optional<DataRef> dataRef{

flang/test/Semantics/expr-errors03.f90

+! RUN: %S/test_errors.sh %s %t %f18
+! Regression test for subscript error recovery
+module m
+  implicit none
+  integer, parameter :: n = 3
+  integer, parameter :: pc(n) = [0, 5, 6]
+ contains
+  logical function f(u)
+    integer :: u
+    !ERROR: No explicit type declared for 'i'
+    do i = 1, n
+      !ERROR: No explicit type declared for 'i'
+      if (pc(i) == u) then
+        f = .true.
+        return
+      end if
+    end do
+    f = .false.
+  end
+end module