[flang] Use derivedType from toAddedum to get updated components

[clementval]

Summary

When the rhs is polymorphic and allocated during assignment, the
derivedType might have change from the one set in toDerived.
Use the one set in the addendum so it is always up to date.

This can happen in cases like the one shown below:

type :: t1
end type t1

type, extends(t1) :: t2
  integer, allocatable :: i(:)
end type

subroutine assign(t)
  class(t2), intent(in) :: t
  class(t1), allocatable :: cp

  cp = t
end subroutine

[jeanPerier]

flang/runtime/assign.cpp

316–317

Probably best to use:

if (const typeInfo::DerivedType *updatedToDerived{toAddendum ? toAddendum->derivedType() : nullptr}) {
  ...

}

so that it is obvious that toAddendum is not null, and the there is a good reason not to use toDerived.

[clementval]

Update toDerived condition.

flang/runtime/assign.cpp

316–317

Update for more safety.

flang/runtime/assign.cpp

terminator.Crash("Assign: mismatching types (to code %d != from code %d)",
         to.type().raw(), from.type().raw());
   }
   std::size_t elementBytes{to.ElementBytes()};
   if (elementBytes != from.ElementBytes()) {
     terminator.Crash(
         "Assign: mismatching element sizes (to %zd bytes != from %zd bytes)",
         elementBytes, from.ElementBytes());
   }
-  if (toDerived) {
+  if (const typeInfo::DerivedType *
+      updatedToDerived{toAddendum ? toAddendum->derivedType() : nullptr}) {
     // 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 (needFinalization) {
-      Finalize(to, *toDerived);
+      Finalize(to, *updatedToDerived);
     }
     // Copy the data components (incl. the parent) first.
-    const Descriptor &componentDesc{toDerived->component()};
+    const Descriptor &componentDesc{updatedToDerived->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) {
for (std::size_t k{0}; k < numComponents; ++k) {
           Assign(*toDesc, *fromDesc, terminator, /*maybeReallocate=*/true,
               /*needFinalization=*/false, componentCanBeDefinedAssignment,
               componentCanBeDefinedAssignment);
         }
         break;
       }
     }
     // Copy procedure pointer components
-    const Descriptor &procPtrDesc{toDerived->procPtr()};
+    const Descriptor &procPtrDesc{updatedToDerived->procPtr()};
     std::size_t numProcPtrs{procPtrDesc.Elements()};
     for (std::size_t k{0}; k < numProcPtrs; ++k) {
       const auto &procPtr{
           *procPtrDesc.ZeroBasedIndexedElement<typeInfo::ProcPtrComponent>(k)};
       for (std::size_t j{0}; j < toElements; ++j, to.IncrementSubscripts(toAt),
            from.IncrementSubscripts(fromAt)) {
         std::memmove(to.Element<char>(toAt) + procPtr.offset,
             from.Element<const char>(fromAt) + procPtr.offset,