[flang] Accept NULL(mold=x) as constant component value in constant structure constructor

[klausler]

Summary

The predicate IsInitialDataTarget() was failing to return a correct true
result in the case of a reference to the intrinsic function NULL() with a
MOLD= argument. Fix, and improve tests for "NULL()" elsewhere in semantics,
checking for an attribute set by intrinsics.cpp rather than the actual name.

[mleair]

LGTM

flang/lib/Evaluate/check-expression.cpp

bool operator()(const Substring &x) const {
     return IsConstantExpr(x.lower()) && IsConstantExpr(x.upper()) &&
         (*this)(x.parent());
   }
   bool operator()(const DescriptorInquiry &) const { return false; }
   template <typename T> bool operator()(const ArrayConstructor<T> &) const {
     return false;
   }
   bool operator()(const StructureConstructor &) const { return false; }
-  template <typename T> bool operator()(const FunctionRef<T> &) {
-    return false;
-  }
   template <typename D, typename R, typename... O>
   bool operator()(const Operation<D, R, O...> &) const {
     return false;
   }
   template <typename T> bool operator()(const Parentheses<T> &x) const {
     return (*this)(x.left());
   }
-  template <typename T> bool operator()(const FunctionRef<T> &x) const {
+  bool operator()(const ProcedureRef &x) const {
+    if (const SpecificIntrinsic * intrinsic{x.proc().GetSpecificIntrinsic()}) {
+      return intrinsic->characteristics.value().attrs.test(
+          characteristics::Procedure::Attr::NullPointer);
+    }
     return false;
   }
   bool operator()(const Relational<SomeType> &) const { return false; }
 
 private:
   bool CheckVarOrComponent(const semantics::Symbol &symbol) {
     const Symbol &ultimate{symbol.GetUltimate()};
     if (IsAllocatable(ultimate)) {
Result operator()(const TypeParamInquiry &inq) const {
     if (scope_.IsDerivedType() && !IsConstantExpr(inq) &&
         inq.base() /* X%T, not local T */) { // C750, C754
       return "non-constant reference to a type parameter inquiry not "
              "allowed for derived type components or type parameter values";
     }
     return std::nullopt;
   }
 
-  template <typename T> Result operator()(const FunctionRef<T> &x) const {
+  Result operator()(const ProcedureRef &x) const {
     if (const auto *symbol{x.proc().GetSymbol()}) {
       const Symbol &ultimate{symbol->GetUltimate()};
       if (!semantics::IsPureProcedure(ultimate)) {
         return "reference to impure function '"s + ultimate.name().ToString() +
             "'";
       }
       if (semantics::IsStmtFunction(ultimate)) {
         return "reference to statement function '"s +
Result operator()(const CoarrayRef &x) const {
     return CheckSubscripts(x.subscript()).has_value();
   }
   Result operator()(const Component &x) const {
     return x.base().Rank() == 0 && (*this)(x.GetLastSymbol()).value_or(false);
   }
   Result operator()(const ComplexPart &) const { return false; }
   Result operator()(const Substring &) const { return false; }
 
-  template <typename T> Result operator()(const FunctionRef<T> &x) const {
+  Result operator()(const ProcedureRef &x) const {
     if (auto chars{
             characteristics::Procedure::Characterize(x.proc(), context_)}) {
       if (chars->functionResult) {
         const auto &result{*chars->functionResult};
         return !result.IsProcedurePointer() &&
             result.attrs.test(characteristics::FunctionResult::Attr::Pointer) &&
             result.attrs.test(
                 characteristics::FunctionResult::Attr::Contiguous);

flang/lib/Semantics/expression.cpp

if (result) {
     }
   }
   return true;
 }
 
 MaybeExpr ExpressionAnalyzer::MakeFunctionRef(parser::CharBlock callSite,
     ProcedureDesignator &&proc, ActualArguments &&arguments) {
   if (const auto *intrinsic{std::get_if<SpecificIntrinsic>(&proc.u)}) {
-    if (intrinsic->name == "null" && arguments.empty()) {
+    if (intrinsic->characteristics.value().attrs.test(
+            characteristics::Procedure::Attr::NullPointer) &&
+        arguments.empty()) {
       return Expr<SomeType>{NullPointer{}};
     }
   }
   if (const Symbol * symbol{proc.GetSymbol()}) {
     if (!ResolveForward(*symbol)) {
       return std::nullopt;
     }
   }