[flang] Handle correctly user defined assignment for allocatable component

[clementval]

Summary

In the Fortran standard 2018 section 10.2.1.3 (13), it is mentioned
that all noncoarray allocatable component must follow this sequence of
operations:

1. If the component of the variable is allocated, it is deallocated.
2. If the component of the value of expr is allocated, the corresponding component of the variable is allocated with the same dynamic type and type parameters as the component of the value of expr. If it is an array, it is allocated with the same bounds. The value of the component of the value of expr is then assigned to the corresponding component of the variable using defined assignment if the declared type of the component has a type-bound defined assignment consistent with the component, and intrinsic assignment for the dynamic type of that component otherwise.

This patch updates the code to make use of the user defined assignment for
allocatable component and make sure the component is allocated correctly.

[klausler]

LGTM and thanks for the correction.

flang/runtime/assign.cpp

if (const typeInfo::DerivedType *
     for (std::size_t k{0}; k < numComponents; ++k) {
       const auto &comp{
           *componentDesc.ZeroBasedIndexedElement<typeInfo::Component>(
               k)}; // TODO: exploit contiguity here
       // Use PolymorphicLHS for components so that the right things happen
       // when the components are polymorphic; when they're not, they're both
       // not, and their declared types will match.
       int nestedFlags{MaybeReallocate | PolymorphicLHS};
-      if (comp.genre() != typeInfo::Component::Genre::Allocatable &&
-          (flags & ComponentCanBeDefinedAssignment)) {
-        // Allocatable components are assigned via intrinsic assignment,
-        // not defined assignment (see F'2018 10.2.1.3 paragraph 13).
+      if (flags & ComponentCanBeDefinedAssignment) {
         nestedFlags |= CanBeDefinedAssignment | ComponentCanBeDefinedAssignment;
       }
       switch (comp.genre()) {
       case typeInfo::Component::Genre::Data:
         if (comp.category() == TypeCategory::Derived) {
           StaticDescriptor<maxRank, true, 10 /*?*/> statDesc[2];
           Descriptor &toCompDesc{statDesc[0].descriptor()};
           Descriptor &fromCompDesc{statDesc[1].descriptor()};
for (std::size_t k{0}; k < numComponents; ++k) {
               // deallocation to the recursive activation of Assign(),
               // which might be able to avoid deallocation/reallocation
               // when the existing allocation can be reoccupied.
               toDesc->Destroy(false /*already finalized*/);
             }
             if (!fromDesc->IsAllocated()) {
               continue; // F'2018 10.2.1.3(13)(2)
             }
+
+            // F'2018 10.2.1.3(13) (2)
+            // If from is allocated, allocate to with the same type.
+            if (nestedFlags & CanBeDefinedAssignment) {
+              if (AllocateAssignmentLHS(
+                      *toDesc, *fromDesc, terminator, nestedFlags) != StatOk) {
+                return;
+              }
+            }
           }
           Assign(*toDesc, *fromDesc, terminator, nestedFlags);
         }
         break;
       }
     }
     // Copy procedure pointer components
     const Descriptor &procPtrDesc{updatedToDerived->procPtr()};