[flang] Defer NAMELIST group item name resolution

[klausler]

Summary

Items in NAMELIST groups might be host-associated implicitly-typed
variables, but name resolution can't know that when the NAMELIST
appears in a specification part and the host's execution part has
not yet been analyzed. So defer NAMELIST group item name resolution
to the end of the execution part. This is safe because nothing
else in name resolution depends on whether a variable is in a
NAMELIST group or not.

flang/lib/Semantics/resolve-names.cpp

struct SpecificationPartState {
     // Info about about SAVE statements and attributes in current scope
     struct {
       std::optional<SourceName> saveAll; // "SAVE" without entity list
       std::set<SourceName> entities; // names of entities with save attr
       std::set<SourceName> commons; // names of common blocks with save attr
     } saveInfo;
   } specPartState_;
 
+  // Some declaration processing can and should be deferred to
+  // ResolveExecutionParts() to avoid prematurely creating implicitly-typed
+  // local symbols that should be host associations.
+  struct DeferredDeclarationState {
+    // The content of each namelist group
+    std::list<const parser::NamelistStmt::Group *> namelistGroups;
+  };
+  DeferredDeclarationState *GetDeferredDeclarationState(bool add = false) {
+    if (!add && deferred_.find(&currScope()) == deferred_.end()) {
+      return nullptr;
+    } else {
+      return &deferred_.emplace(&currScope(), DeferredDeclarationState{})
+                  .first->second;
+    }
+  }
+
 private:
   Scope *currScope_{nullptr};
   FuncResultStack funcResultStack_{*this};
+  std::map<Scope *, DeferredDeclarationState> deferred_;
 };
 
 class ModuleVisitor : public virtual ScopeHandler {
 public:
   bool Pre(const parser::AccessStmt &);
   bool Pre(const parser::Only &);
   bool Pre(const parser::Rename::Names &);
   bool Pre(const parser::Rename::Operators &);
protected:
   Symbol &MakeCommonBlockSymbol(const std::optional<parser::Name> &);
   bool CheckUseError(const parser::Name &);
   void CheckAccessibility(const SourceName &, bool, Symbol &);
   void CheckCommonBlocks();
   void CheckSaveStmts();
   void CheckEquivalenceSets();
   bool CheckNotInBlock(const char *);
   bool NameIsKnownOrIntrinsic(const parser::Name &);
+  void FinishNamelists();
 
   // Each of these returns a pointer to a resolved Name (i.e. with symbol)
   // or nullptr in case of error.
   const parser::Name *ResolveStructureComponent(
       const parser::StructureComponent &);
   const parser::Name *ResolveDataRef(const parser::DataRef &);
   const parser::Name *ResolveName(const parser::Name &);
   bool PassesSharedLocalityChecks(const parser::Name &name, Symbol &symbol);
bool DeclarationVisitor::Pre(const parser::BasedPointerStmt &x) {
   }
   return false;
 }
 
 bool DeclarationVisitor::Pre(const parser::NamelistStmt::Group &x) {
   if (!CheckNotInBlock("NAMELIST")) { // C1107
     return false;
   }
+  const auto &groupName{std::get<parser::Name>(x.t)};
+  auto *groupSymbol{FindInScope(groupName)};
+  if (!groupSymbol || !groupSymbol->has<NamelistDetails>()) {
+    groupSymbol = &MakeSymbol(groupName, NamelistDetails{});
+    groupSymbol->ReplaceName(groupName.source);
+  }
+  // Name resolution of group items is deferred to FinishNamelists()
+  // so that host association is handled correctly.
+  GetDeferredDeclarationState(true)->namelistGroups.emplace_back(&x);
+  return false;
+}
 
-  NamelistDetails details;
-  for (const auto &name : std::get<std::list<parser::Name>>(x.t)) {
+void DeclarationVisitor::FinishNamelists() {
+  if (auto *deferred{GetDeferredDeclarationState()}) {
+    for (const parser::NamelistStmt::Group *group : deferred->namelistGroups) {
+      if (auto *groupSymbol{FindInScope(std::get<parser::Name>(group->t))}) {
+        if (auto *details{groupSymbol->detailsIf<NamelistDetails>()}) {
+          for (const auto &name : std::get<std::list<parser::Name>>(group->t)) {
             auto *symbol{FindSymbol(name)};
             if (!symbol) {
               symbol = &MakeSymbol(name, ObjectEntityDetails{});
               ApplyImplicitRules(*symbol);
             } else if (!ConvertToObjectEntity(*symbol)) {
               SayWithDecl(name, *symbol, "'%s' is not a variable"_err_en_US);
             }
             symbol->GetUltimate().set(Symbol::Flag::InNamelist);
-    details.add_object(*symbol);
+            details->add_object(*symbol);
           }
-
-  const auto &groupName{std::get<parser::Name>(x.t)};
-  auto *groupSymbol{FindInScope(groupName)};
-  if (!groupSymbol || !groupSymbol->has<NamelistDetails>()) {
-    groupSymbol = &MakeSymbol(groupName, std::move(details));
-    groupSymbol->ReplaceName(groupName.source);
         }
-  groupSymbol->get<NamelistDetails>().add_objects(details.objects());
-  return false;
+      }
+    }
+    deferred->namelistGroups.clear();
+  }
 }
 
 bool DeclarationVisitor::Pre(const parser::IoControlSpec &x) {
   if (const auto *name{std::get_if<parser::Name>(&x.u)}) {
     auto *symbol{FindSymbol(*name)};
     if (!symbol) {
       Say(*name, "Namelist group '%s' not found"_err_en_US);
     } else if (!symbol->GetUltimate().has<NamelistDetails>()) {

 void ResolveNamesVisitor::ResolveExecutionParts(const ProgramTree &node) {
   if (!node.scope()) {
     return; // error occurred creating scope
   }
   SetScope(*node.scope());
   if (const auto *exec{node.exec()}) {
     Walk(*exec);
   }
+  FinishNamelists();
   PopScope(); // converts unclassified entities into objects
   for (const auto &child : node.children()) {
     ResolveExecutionParts(child);
   }
 }
 
 void ResolveNamesVisitor::Post(const parser::Program &) {
   // ensure that all temps were deallocated

flang/test/Semantics/call19.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1
 ! Ensures that things that aren't procedures aren't allowed to be called.
 module m
   integer :: i
   integer, pointer :: ip
   type :: t
   end type
   type :: pdt(k,len)
     integer, kind :: k
     integer, len :: len
   end type
   type(pdt(1,2)) :: x
+  !ERROR: 'i' is not a variable
   namelist /nml/i
  contains
   subroutine s(d)
     real d
     !ERROR: 'm' is not a callable procedure
     call m
     !ERROR: Cannot call function 'i' like a subroutine
     call i

flang/test/Semantics/resolve40.f90

subroutine s4b
   use m4
   real :: y
   !ERROR: 'nl' is already declared in this scoping unit
   namelist /nl/y
 end
 
 subroutine s5
   namelist /nl/x
-  !ERROR: The type of 'x' has already been implicitly declared
   integer x
 end
 
 subroutine s6
   !ERROR: 's6' is not a variable
   namelist /nl/ s6
   !ERROR: 'f' is not a variable
   namelist /nl/ f
 contains
   integer function f()
     f = 1
   end
 end
 
 subroutine s7
   real x
+  !ERROR: 'x' is not a variable
   namelist /nl/ x
-  !ERROR: EXTERNAL attribute not allowed on 'x'
   external x
 end
 
 subroutine s8
   data x/1.0/
   !ERROR: The type of 'x' has already been implicitly declared
   integer x
 end