[flang] Avoid cascading error in subscript triplet

[tskeith]

Summary

If a bound of a subscript triplet is present but fails to analyze
due to an error, return nullopt rather than returning a Triplet with
that bound missing. This is so we can distinguish an absent bound from
an erroneous one and avoid spurious errors.

flang/lib/Semantics/expression.cpp

if (s) {
     return AsSubscript(Analyze(*s));
   } else {
     return std::nullopt;
   }
 }
 
 std::optional<Subscript> ExpressionAnalyzer::AnalyzeSectionSubscript(
     const parser::SectionSubscript &ss) {
-  return std::visit(common::visitors{
-                        [&](const parser::SubscriptTriplet &t) {
-                          return std::make_optional<Subscript>(
-                              Triplet{TripletPart(std::get<0>(t.t)),
-                                  TripletPart(std::get<1>(t.t)),
-                                  TripletPart(std::get<2>(t.t))});
-                        },
-                        [&](const auto &s) -> std::optional<Subscript> {
-                          if (auto subscriptExpr{AsSubscript(Analyze(s))}) {
-                            return Subscript{std::move(*subscriptExpr)};
-                          } else {
-                            return std::nullopt;
-                          }
-                        },
-                    },
+  return std::visit(
+      common::visitors{
+          [&](const parser::SubscriptTriplet &t) -> std::optional<Subscript> {
+            const auto &lower{std::get<0>(t.t)};
+            const auto &upper{std::get<1>(t.t)};
+            const auto &stride{std::get<2>(t.t)};
+            auto result{Triplet{
+                TripletPart(lower), TripletPart(upper), TripletPart(stride)}};
+            if ((lower && !result.lower()) || (upper && !result.upper())) {
+              return std::nullopt;
+            } else {
+              return std::make_optional<Subscript>(result);
+            }
       ss.u);
 }
 
 // Empty result means an error occurred
 std::vector<Subscript> ExpressionAnalyzer::AnalyzeSectionSubscripts(
     const std::list<parser::SectionSubscript> &sss) {
   bool error{false};
   std::vector<Subscript> subscripts;

flang/test/Semantics/assign04.f90

subroutine s8
   !ERROR: Assignment to subprogram 's8' is not allowed
   s8 = 1.0
 end
 
 real function f9() result(r)
   !ERROR: Assignment to subprogram 'f9' is not allowed
   f9 = 1.0
 end
+
+!ERROR: No explicit type declared for 'n'
+subroutine s10(a, n)
+  implicit none
+  real a(n)
+  a(1:n) = 0.0  ! should not get a second error here
+end