[flang] Improve error message for misuse of NULL(mold) as data statement constant

[klausler]

Summary

While "null()" is accepted as a data statement constant when it
corresponds to a pointer object, "null(mold=p)" and "null(p)"
are not allowed. The current error messages simply complain
that null is not an array. This patch adds a context-sensitive
message to the effect that a data statement constant followed
by non-empty parentheses must be an array or structure constructor.

(Note that f18 can't simply special-case the name "null" when parsing
data statement constants, since programs are free to repurpose that
name as an array or derived type.)

flang/include/flang/Semantics/expression.h

private:
   bool CheckIsValidForwardReference(const semantics::DerivedTypeSpec &);
 
   semantics::SemanticsContext &context_;
   FoldingContext &foldingContext_{context_.foldingContext()};
   std::map<parser::CharBlock, int> impliedDos_; // values are INTEGER kinds
   bool isWholeAssumedSizeArrayOk_{false};
   bool useSavedTypedExprs_{true};
   bool inWhereBody_{false};
+  bool inDataStmtConstant_{false};
   friend class ArgumentAnalyzer;
 };
 
 inline bool AreConformable(int leftRank, int rightRank) {
   return leftRank == 0 || rightRank == 0 || leftRank == rightRank;
 }
 
 template <typename L, typename R>

flang/lib/Semantics/expression.cpp

MaybeExpr baseExpr;
     baseExpr = Analyze(ae.base);
   }
   if (baseExpr) {
     if (ae.subscripts.empty()) {
       // will be converted to function call later or error reported
     } else if (baseExpr->Rank() == 0) {
       if (const Symbol * symbol{GetLastSymbol(*baseExpr)}) {
         if (!context_.HasError(symbol)) {
+          if (inDataStmtConstant_) {
+            // Better error for NULL(X) with a MOLD= argument
+            Say("'%s' must be an array or structure constructor if used with non-empty parentheses as a DATA statement constant"_err_en_US,
+                symbol->name());
+          } else {
             Say("'%s' is not an array"_err_en_US, symbol->name());
+          }
           context_.SetError(*symbol);
         }
       }
     } else if (std::optional<DataRef> dataRef{
                    ExtractDataRef(std::move(*baseExpr))}) {
       return ApplySubscripts(
           std::move(*dataRef), AnalyzeSectionSubscripts(ae.subscripts));
     } else {
if (!useSavedTypedExprs_ || !var->typedExpr) {
       }
     }
   }
   // Not a Variable -> FunctionReference; handle normally as Variable or Expr
   return Analyze(selector.u);
 }
 
 MaybeExpr ExpressionAnalyzer::Analyze(const parser::DataStmtConstant &x) {
+  auto restorer{common::ScopedSet(inDataStmtConstant_, true)};
   return ExprOrVariable(x, x.source);
 }
 
 MaybeExpr ExpressionAnalyzer::Analyze(const parser::AllocateObject &x) {
   return ExprOrVariable(x, parser::FindSourceLocation(x));
 }
 
 MaybeExpr ExpressionAnalyzer::Analyze(const parser::PointerObject &x) {

flang/test/Semantics/data01.f90

 subroutine CheckValue
   use m1
   !ERROR: USE-associated object 'associated' must not be initialized in a DATA statement
   data associated / person(1, 'Abcd Ijkl') /
   type(person) myName(3)
   !OK: constant structure constructor
   data myname(1) / person(1, 'Abcd Ijkl') /
   !C883
-  !ERROR: 'persn' is not an array
+  !ERROR: 'persn' must be an array or structure constructor if used with non-empty parentheses as a DATA statement constant
   data myname(2) / persn(2, 'Abcd Efgh') /
   !C884
   !ERROR: DATA statement value 'person(age=myage,name="Abcd Ijkl                ")' for 'myname(3_8)%age' is not a constant
   data myname(3) / person(myAge, 'Abcd Ijkl') /
   integer, parameter :: a(5) =(/11, 22, 33, 44, 55/)
   integer :: b(5) =(/11, 22, 33, 44, 55/)
   integer :: i
   integer :: x, y, z
   !OK: constant array element
   data x / a(1) /
   !C886, C887
   !ERROR: DATA statement value 'a(int(i,kind=8))' for 'y' is not a constant
   data y / a(i) /
   !ERROR: DATA statement value 'b(1_8)' for 'z' is not a constant
   data z / b(1) /
 end

flang/test/Semantics/null-init.f90

module m9b
   integer, pointer :: p => renamed()
   !ERROR: Pointer initializer must be intrinsic NULL()
   integer, pointer :: q => null()
   integer, pointer :: d1, d2
   data d1/renamed()/
   !ERROR: An initial data target must be a designator with constant subscripts
   data d2/null()/
 end module
+
+subroutine m10
+  real, pointer :: x, y
+  !ERROR: 'null' must be an array or structure constructor if used with non-empty parentheses as a DATA statement constant
+  data x/null(y)/
+end
+
+subroutine m11
+  type :: null
+    integer :: mold
+  end type
+  type(null) :: obj(2)
+  integer, parameter :: j = 0
+  data obj/null(mold=j), null(j)/ ! both fine
+end subroutine
+
+subroutine m12
+  integer, parameter :: j = 1
+  integer, target, save :: null(1)
+  integer, pointer :: p
+  data p/null(j)/ ! ok
+end subroutine