[flang] Catch more bad DATA statement objects

[klausler]

Summary

The data statement variable checker is missing some cases, like expressions
that are not variables. Run the checker first to enjoy its very specific
error messages, but when it finds no problems, still apply a general
check that an expression is a "variable" and also not a constant expression
at the top level as a backstop.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Semantics/check-data.cpp

private:
   SemanticsContext &context_;
   parser::CharBlock source_;
   bool hasComponent_{false};
   bool hasSubscript_{false};
   bool isPointerAllowed_{true};
   bool isFirstSymbol_{true};
 };
 
+static bool IsValidDataObject(const SomeExpr &expr) { // C878, C879
+  return !evaluate::IsConstantExpr(expr) &&
+      (evaluate::IsVariable(expr) || evaluate::IsProcedurePointer(expr));
+}
+
 void DataChecker::Leave(const parser::DataIDoObject &object) {
   if (const auto *designator{
           std::get_if<parser::Scalar<common::Indirection<parser::Designator>>>(
               &object.u)}) {
     if (MaybeExpr expr{exprAnalyzer_.Analyze(*designator)}) {
       auto source{designator->thing.value().source};
-      if (evaluate::IsConstantExpr(*expr)) { // C878,C879
-        exprAnalyzer_.context().Say(
-            source, "Data implied do object must be a variable"_err_en_US);
-      } else {
-        DataVarChecker checker{exprAnalyzer_.context(), source};
-        if (checker(*expr)) {
-          if (checker.HasComponentWithoutSubscripts()) { // C880
-            exprAnalyzer_.context().Say(source,
-                "Data implied do structure component must be subscripted"_err_en_US);
-          } else {
-            return;
-          }
-        }
-      }
-    }
+        } else if (!IsValidDataObject(*expr)) {
+          exprAnalyzer_.context().Say(
+              source, "Data implied do object must be a variable"_err_en_US);
     currentSetHasFatalErrors_ = true;
   }
 }
 
 void DataChecker::Leave(const parser::DataStmtObject &dataObject) {
   common::visit(
       common::visitors{
           [](const parser::DataImpliedDo &) { // has own Enter()/Leave()
           },
           [&](const auto &var) {
             auto expr{exprAnalyzer_.Analyze(var)};
+            auto source{parser::FindSourceLocation(dataObject)};
             if (!expr ||
-                !DataVarChecker{exprAnalyzer_.context(),
-                    parser::FindSourceLocation(dataObject)}(*expr)) {
+                !DataVarChecker{exprAnalyzer_.context(), source}(*expr)) {
+              currentSetHasFatalErrors_ = true;
+            } else if (!IsValidDataObject(*expr)) {
+              exprAnalyzer_.context().Say(
+                  source, "Data statement object must be a variable"_err_en_US);
               currentSetHasFatalErrors_ = true;
             }
           },
       },
       dataObject.u);
 }
 
 void DataChecker::Leave(const parser::DataStmtSet &set) {

flang/test/Semantics/data03.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1
-!Testing data constraints : C874 - C875, C878 - C881 
+!Testing data constraints : C874 - C875, C878 - C881
 module m
     integer, target :: modarray(1)
   contains
     function f(i)
       integer, intent(in) :: i
       integer, pointer :: f
       f => modarray(i)
     end
-    subroutine CheckObject 
+    subroutine CheckObject
       type specialNumbers
         integer one
         integer numbers(5)
       end type
       type large
         integer elt(10)
         integer val
         type(specialNumbers) nums
subroutine CheckObject
       type(large) largeNumber
       real :: a[*]
       real :: b(5)
       integer :: x
       real, parameter:: c(5) = (/ 1, 2, 3, 4, 5 /)
       integer :: d(10, 10)
       character :: name(12)
       integer :: ind = 2
+      !ERROR: Data statement object must be a variable
+      DATA name%len / 666 /
       !C874
       !ERROR: Data object must not be a coindexed variable
       DATA a[1] / 1 /
       !C874
       !ERROR: Data object must not be a coindexed variable
       DATA(a[i], i = 1, 5) / 5 * 1 /
       !C875
       !ERROR: Data object variable must not be a function reference
subroutine CheckObject
       !OK: Correct use
       DATA(largeArray(j) % nums % one, j = 1, 5) / 5 * 1 /
       !C880
       !OK: Correct use
       DATA(largeNumber % numsArray(j) % one, j = 1, 5) / 5 * 1 /
       !C881
       !ERROR: Data object must have constant subscripts
       DATA(b(x), i = 1, 5) / 5 * 1 /
-      !C881 
+      !C881
       !OK: Correct use
       DATA(nums % numbers(i), i = 1, 5) / 5 * 1 /
       !C881
       !OK: Correct use
       DATA((d(i, j), i = 1, 10), j = 1, 10) / 100 * 1 /
       !C881
       !OK: Correct use
       DATA(d(i, 1), i = 1, 10) / 10 * 1 /
-    end 
+    end
   end