[flang] Avoid double finalization in Assign

[clementval]

Summary

First call to Assign is issuing finalization for the
LHS and its components. Avoid calling finalization for components
again when doing the component by component assignment.

flang/runtime/assign.cpp

 // Assigns one object to another via intrinsic assignment (F'2018 10.2.1.3) or
 // type-bound (only!) defined assignment (10.2.1.4), as appropriate.  Performs
 // finalization, scalar expansion, & allocatable (re)allocation as needed.
 // Does not perform intrinsic assignment implicit type conversion.  Both
 // descriptors must be initialized.  Recurses as needed to handle components.
 // Do not perform allocatable reallocation if \p skipRealloc is true, which is
 // used for allocate statement with source specifier.
 static void Assign(Descriptor &to, const Descriptor &from,
-    Terminator &terminator, bool skipRealloc = false) {
+    Terminator &terminator, bool skipRealloc = false,
+    bool skipFinalization = false) {
   DescriptorAddendum *toAddendum{to.Addendum()};
   const typeInfo::DerivedType *toDerived{
       toAddendum ? toAddendum->derivedType() : nullptr};
   const DescriptorAddendum *fromAddendum{from.Addendum()};
   const typeInfo::DerivedType *fromDerived{
       fromAddendum ? fromAddendum->derivedType() : nullptr};
   bool wasJustAllocated{false};
   if (to.IsAllocatable()) {
if (toDerived) { // Derived type assignment
     if (const auto *special{toDerived->FindSpecialBinding(
             typeInfo::SpecialBinding::Which::ElementalAssignment)}) {
       return DoElementalDefinedAssignment(
           to, from, *special, toElements, toAt, fromAt);
     }
     // Derived type intrinsic assignment, which is componentwise and elementwise
     // for all components, including parent components (10.2.1.2-3).
     // The target is first finalized if still necessary (7.5.6.3(1))
-    if (!wasJustAllocated && !toDerived->noFinalizationNeeded()) {
+    if (!wasJustAllocated && !toDerived->noFinalizationNeeded() &&
+        !skipFinalization) {
       Finalize(to, *toDerived);
     }
     // Copy the data components (incl. the parent) first.
     const Descriptor &componentDesc{toDerived->component()};
     std::size_t numComponents{componentDesc.Elements()};
     for (std::size_t k{0}; k < numComponents; ++k) {
       const auto &comp{
           *componentDesc.ZeroBasedIndexedElement<typeInfo::Component>(
               k)}; // TODO: exploit contiguity here
       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 j{0}; j < toElements; ++j,
                to.IncrementSubscripts(toAt), from.IncrementSubscripts(fromAt)) {
             comp.CreatePointerDescriptor(toCompDesc, to, terminator, toAt);
             comp.CreatePointerDescriptor(
                 fromCompDesc, from, terminator, fromAt);
-            Assign(toCompDesc, fromCompDesc, terminator, /*skipRealloc=*/false);
+            Assign(toCompDesc, fromCompDesc, terminator, /*skipRealloc=*/false,
+                /*skipFinalization=*/true);
           }
         } else { // Component has intrinsic type; simply copy raw bytes
           std::size_t componentByteSize{comp.SizeInBytes(to)};
           for (std::size_t j{0}; j < toElements; ++j,
                to.IncrementSubscripts(toAt), from.IncrementSubscripts(fromAt)) {
             std::memmove(to.Element<char>(toAt) + comp.offset(),
                 from.Element<const char>(fromAt) + comp.offset(),
                 componentByteSize);