[flang] Make uninitialized allocatable components explicitly NULL() in structure constructors

[klausler]

Summary

When a structure constructor does not initialize an allocatable component,
ensure that the typed expression representation contains an explicit
NULL() for the component. Expression semantics already copies default
initialized expressions for nonallocatable components into structure
constructors. This change is expected to simplify lowering.

flang/lib/Evaluate/check-expression.cpp

struct IsActuallyConstantHelper {
   template <typename A> bool operator()(const A &) { return false; }
   template <typename T> bool operator()(const Constant<T> &) { return true; }
   template <typename T> bool operator()(const Parentheses<T> &x) {
     return (*this)(x.left());
   }
   template <typename T> bool operator()(const Expr<T> &x) {
     return std::visit([=](const auto &y) { return (*this)(y); }, x.u);
   }
+  bool operator()(const Expr<SomeType> &x) {
+    if (IsNullPointer(x)) {
+      return true;
+    }
+    return std::visit([this](const auto &y) { return (*this)(y); }, x.u);
+  }
   template <typename A> bool operator()(const A *x) { return x && (*this)(*x); }
   template <typename A> bool operator()(const std::optional<A> &x) {
     return x && (*this)(*x);
   }
 };
 
 template <typename A> bool IsActuallyConstant(const A &x) {
   return IsActuallyConstantHelper{}(x);

flang/lib/Semantics/expression.cpp

if (symbol) {
           } else {
             AttachDeclaration(
                 Say(expr.source,
                     "Shape of component '%s' cannot be determined"_err_en_US,
                     symbol->name()),
                 *symbol);
           }
         } else if (IsAllocatable(*symbol) && IsBareNullPointer(&*value)) {
-          // NULL() with no arguments allowed by 7.5.10 para 6 for ALLOCATABLE
+          // NULL() with no arguments allowed by 7.5.10 para 6 for ALLOCATABLE.
+          result.Add(*symbol, Expr<SomeType>{NullPointer{}});
         } else if (auto symType{DynamicType::From(symbol)}) {
           if (IsAllocatable(*symbol) && symType->IsUnlimitedPolymorphic() &&
               valueType) {
             // ok
           } else if (valueType) {
             AttachDeclaration(
                 Say(expr.source,
                     "Value in structure constructor of type '%s' is "
if (symbol) {
         }
       }
     }
   }
 
   // Ensure that unmentioned component objects have default initializers.
   for (const Symbol &symbol : components) {
     if (!symbol.test(Symbol::Flag::ParentComp) &&
-        unavailable.find(symbol.name()) == unavailable.cend() &&
-        !IsAllocatable(symbol)) {
-      if (const auto *details{
+        unavailable.find(symbol.name()) == unavailable.cend()) {
+      if (IsAllocatable(symbol)) {
+        // Set all remaining allocatables to explicit NULL()
+        result.Add(symbol, Expr<SomeType>{NullPointer{}});
+      } else if (const auto *details{
                      symbol.detailsIf<semantics::ObjectEntityDetails>()}) {
         if (details->init()) {
           result.Add(symbol, common::Clone(*details->init()));
         } else { // C799
           AttachDeclaration(Say(typeName,
                                 "Structure constructor lacks a value for "
                                 "component '%s'"_err_en_US,
                                 symbol.name()),
               symbol);

flang/test/Semantics/modfile45.f90

+! RUN: %python %S/test_modfile.py %s %flang_fc1
+! Ensures that uninitialized allocatable components in a structure constructor
+! appear with explicit NULL() in the expression representation.
+module m
+  type t
+    real, allocatable :: x1, x2, x3
+  end type
+  type t2
+    type(t) :: a = t(NULL(),x2=NULL())
+  end type
+end module
+
+!Expect: m.mod
+!module m
+!type::t
+!real(4),allocatable::x1
+!real(4),allocatable::x2
+!real(4),allocatable::x3
+!end type
+!type::t2
+!type(t)::a=t(x1=NULL(),x2=NULL(),x3=NULL())
+!end type
+!intrinsic::null
+!end

flang/test/Semantics/oldparam02.f90

 ! RUN: not %flang -falternative-parameter-statement -fsyntax-only %s 2>&1 | FileCheck %s
 
 ! Error tests for "old style" PARAMETER statements
 subroutine subr(x1,x2,x3,x4,x5)
   type(*), intent(in) :: x1
   class(*), intent(in) :: x2
   real, intent(in) :: x3(*)
   real, intent(in) :: x4(:)
   character(*), intent(in) :: x5
   !CHECK: error: TYPE(*) dummy argument may only be used as an actual argument
   parameter p1 = x1
   !CHECK: error: Must be a constant value
   parameter p2 = x2
   !CHECK: error: Whole assumed-size array 'x3' may not appear here without subscripts
+  !CHECK: error: Must be a constant value
   parameter p3 = x3
   !CHECK: error: Must be a constant value
   parameter p4 = x4
   !CHECK: error: Must be a constant value
   parameter p5 = x5
   !CHECK: The expression must be a constant of known type
   parameter p6 = z'feedfacedeadbeef'
   !CHECK: error: Must be a constant value
   parameter p7 = len(x5)
   real :: p8
   !CHECK: error: Alternative style PARAMETER 'p8' must not already have an explicit type
   parameter p8 = 666
 end