[flang] Avoid crash from forward referenced derived type

[klausler]

Summary

Fortran permits forward references to derived types in contexts that don't
require knowledge of the derived type definition for semantic analysis,
such as in the declaration of a pointer or allocatable variable or component.
But when the forward-referenced derived type is used later for a component
reference, it is possible for the DerivedTypeSpec in he base variable or component
declaration to still have a null scope pointer even if the type has been defined,
since DerivedTypeSpec and TypeSpec objects are created in scopes of use
rather than in scopes of definition. The fix is to call
DerivedTypeSpec::Instantiate() in the name resolution of each component
name so that the scope gets filled in if it is still null.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Semantics/resolve-names.cpp

for (const auto &typeParamSpec :
     // non-defaulted type parameters are evaluated (folded) in the enclosing
     // scope.  The KIND/LEN distinction is resolved later in
     // DerivedTypeSpec::CookParameters().
     ParamValue param{GetParamValue(value, common::TypeParamAttr::Kind)};
     if (!param.isExplicit() || param.GetExplicit()) {
       spec->AddRawParamValue(optKeyword, std::move(param));
     }
   }
-
   // The DerivedTypeSpec *spec is used initially as a search key.
   // If it turns out to have the same name and actual parameter
   // value expressions as another DerivedTypeSpec in the current
   // scope does, then we'll use that extant spec; otherwise, when this
   // spec is distinct from all derived types previously instantiated
   // in the current scope, this spec will be moved into that collection.
   const auto &dtDetails{spec->typeSymbol().get<DerivedTypeDetails>()};
   auto category{GetDeclTypeSpecCategory()};
if (component.source == "kind") {
       } else if (component.source == "im") {
         miscKind = MiscDetails::Kind::ComplexPartIm;
       }
     }
     if (miscKind != MiscDetails::Kind::None) {
       MakePlaceholder(component, miscKind);
       return &component;
     }
-  } else if (const DerivedTypeSpec * derived{type->AsDerived()}) {
+  } else if (DerivedTypeSpec * derived{type->AsDerived()}) {
+    derived->Instantiate(currScope()); // in case of forward referenced type
     if (const Scope * scope{derived->scope()}) {
       if (Resolve(component, scope->FindComponent(component.source))) {
         if (auto msg{
                 CheckAccessibleComponent(currScope(), *component.symbol)}) {
           context().Say(component.source, *msg);
         }
         return &component;
       } else {

flang/test/Semantics/symbol21.f90

+! RUN: %python %S/test_symbols.py %s %flang_fc1
+! Derived type forward reference regression case
+
+ !DEF: /MainProgram1/t2 DerivedType
+ type :: t2
+  !DEF: /MainProgram1/t1 DerivedType
+  !DEF: /MainProgram1/t2/ptr POINTER ObjectEntity TYPE(t1)
+  type(t1), pointer :: ptr
+ end type
+ !REF: /MainProgram1/t1
+ type :: t1
+  !DEF: /MainProgram1/t1/a ObjectEntity REAL(4)
+  real :: a
+  !REF: /MainProgram1/t2
+  !DEF: /MainProgram1/t1/p2 POINTER ObjectEntity TYPE(t2)
+  type(t2), pointer :: p2
+  !REF: /MainProgram1/t1
+  !DEF: /MainProgram1/t1/p1 POINTER ObjectEntity TYPE(t1)
+  type(t1), pointer :: p1
+ end type
+ !REF: /MainProgram1/t1
+ !DEF: /MainProgram1/x1 POINTER ObjectEntity TYPE(t1)
+ !DEF: /MainProgram1/x2 POINTER ObjectEntity TYPE(t1)
+ type(t1), pointer :: x1, x2
+ !REF: /MainProgram1/x2
+ !REF: /MainProgram1/t1/p1
+ !REF: /MainProgram1/t1/a
+ !REF: /MainProgram1/x1
+ x2%p1%a = x1%a
+end program