[flang] Fix bug resolving type in type definition

[tskeith]

Summary

When we encountered a type name in a derived type definition, we were
sometimes finding a component of that name rather than the type from
the enclosing scope. Fix this by introducing NonDerivedTypeScope() to
start the search in the right scope.

[PeteSteinfeld]

Looks good to me.

[tskeith]

• Add test with type parameters

flang/lib/Semantics/resolve-names.cpp

public:
   using ImplicitRulesVisitor::Post;
   using ImplicitRulesVisitor::Pre;
 
   Scope &currScope() { return DEREF(currScope_); }
   // The enclosing scope, skipping blocks and derived types.
   // TODO: Will return the scope of a FORALL or implied DO loop; is this ok?
   // If not, should call FindProgramUnitContaining() instead.
   Scope &InclusiveScope();
+  // The enclosing scope, skipping derived types.
+  Scope &NonDerivedTypeScope();
 
   // Create a new scope and push it on the scope stack.
   void PushScope(Scope::Kind kind, Symbol *symbol);
   void PushScope(Scope &scope);
   void PopScope();
   void SetScope(Scope &);
 
   template <typename T> bool Pre(const parser::Statement<T> &x) {
Scope &ScopeHandler::InclusiveScope() {
   for (auto *scope{&currScope()};; scope = &scope->parent()) {
     if (scope->kind() != Scope::Kind::Block && !scope->IsDerivedType()) {
       return *scope;
     }
   }
   DIE("inclusive scope not found");
 }
 
+Scope &ScopeHandler::NonDerivedTypeScope() {
+  return currScope_->IsDerivedType() ? currScope_->parent() : *currScope_;
+}
+
 void ScopeHandler::PushScope(Scope::Kind kind, Symbol *symbol) {
   PushScope(currScope().MakeScope(kind, symbol));
 }
 void ScopeHandler::PushScope(Scope &scope) {
   currScope_ = &scope;
   auto kind{currScope_->kind()};
   if (kind != Scope::Kind::Block) {
     BeginScope(scope);

 }
 
 void DeclarationVisitor::Post(const parser::EnumDef &) {
   enumerationState_ = EnumeratorState{};
 }
 
 bool DeclarationVisitor::Pre(const parser::AccessSpec &x) {
   Attr attr{AccessSpecToAttr(x)};
-  const Scope &scope{
-      currScope().IsDerivedType() ? currScope().parent() : currScope()};
-  if (!scope.IsModule()) { // C817
+  if (!NonDerivedTypeScope().IsModule()) { // C817
     Say(currStmtSource().value(),
         "%s attribute may only appear in the specification part of a module"_err_en_US,
         EnumToString(attr));
   }
   CheckAndSet(attr);
   return false;
 }
 
if (!prevType) {
     context().SetError(symbol);
   } else {
     symbol.set(Symbol::Flag::Implicit, false);
   }
 }
 
 std::optional<DerivedTypeSpec> DeclarationVisitor::ResolveDerivedType(
     const parser::Name &name) {
-  Symbol *symbol{FindSymbol(name)};
+  Symbol *symbol{FindSymbol(NonDerivedTypeScope(), name)};
   if (!symbol || symbol->has<UnknownDetails>()) {
     if (allowForwardReferenceToDerivedType()) {
       if (!symbol) {
         symbol = &MakeSymbol(InclusiveScope(), name.source, Attrs{});
         Resolve(name, *symbol);
       };
       DerivedTypeDetails details;
       details.set_isForwardReferenced();
std::visit(
       },
       std::get<parser::ProcedureDesignator>(call.t).u);
   Walk(std::get<std::list<parser::ActualArgSpec>>(call.t));
 }
 
 void ResolveNamesVisitor::HandleProcedureName(
     Symbol::Flag flag, const parser::Name &name) {
   CHECK(flag == Symbol::Flag::Function || flag == Symbol::Flag::Subroutine);
-  auto *symbol{FindSymbol(name)};
+  auto *symbol{FindSymbol(NonDerivedTypeScope(), name)};
   if (!symbol) {
     if (context().intrinsics().IsIntrinsic(name.source.ToString())) {
       symbol =
           &MakeSymbol(InclusiveScope(), name.source, Attrs{Attr::INTRINSIC});
     } else {
       symbol = &MakeSymbol(context().globalScope(), name.source, Attrs{});
     }
     Resolve(name, *symbol);

flang/test/Semantics/resolve92.f90

+! RUN: %S/test_errors.sh %s %t %f18
+
+module m1
+  implicit none
+  type t
+    integer :: n
+  end type
+  type t2
+    ! t and t2 must be resolved to types in m, not components in t2
+    type(t) :: t(10) = t(1)
+    type(t) :: x = t(1)
+    integer :: t2
+    type(t2), pointer :: p
+  end type
+end
+
+module m2
+  type :: t(t)
+    integer, kind :: t
+    integer(t) :: n
+  end type
+  type :: t2(t)
+    integer, kind :: t
+    type(t(t)) :: x = t(t)(t)
+  end type
+end