[flang] Enable more usage of generics with forward-referenced specifics in specification parts

[klausler]

Summary

Earlier work allowed a specification expression to reference a generic function
that was defined earlier, so long as the relevant specific procedure of the
generic had been defined before the generic. This patch extends that work
so that the generic can also be used in cases where the relevant specific
procedure has been defined after the generic and before the reference.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Semantics/resolve-names.cpp

private:
   SemanticsContext *context_;
 };
 
 // Inheritance graph for the parse tree visitation classes that follow:
 //   BaseVisitor
 //   + AttrsVisitor
 //   | + DeclTypeSpecVisitor
 //   |   + ImplicitRulesVisitor
-//   |     + ScopeHandler -----------+--+
-//   |       + ModuleVisitor ========|==+
-//   |       + InterfaceVisitor      |  |
-//   |       +-+ SubprogramVisitor ==|==+
-//   + ArraySpecVisitor              |  |
-//     + DeclarationVisitor <--------+  |
-//       + ConstructVisitor             |
-//         + ResolveNamesVisitor <------+
+//   |     + ScopeHandler ------------------+
+//   |       + ModuleVisitor -------------+ |
+//   |       + GenericHandler -------+    | |
+//   |       | + InterfaceVisitor    |    | |
+//   |       +-+ SubprogramVisitor ==|==+ | |
+//   + ArraySpecVisitor              |  | | |
+//     + DeclarationVisitor <--------+  | | |
+//       + ConstructVisitor             | | |
+//         + ResolveNamesVisitor <------+-+-+
 
 class BaseVisitor {
 public:
   BaseVisitor() { DIE("BaseVisitor: default-constructed"); }
   BaseVisitor(
       SemanticsContext &c, ResolveNamesVisitor &v, ImplicitRulesMap &rules)
       : implicitRulesMap_{&rules}, this_{&v}, context_{&c}, messageHandler_{c} {
   }
private:
   }
   bool IsUseOnly(const SourceName &name) const {
     return useOnly_.find({name, useModuleScope_}) != useOnly_.end();
   }
   Scope *FindModule(const parser::Name &, std::optional<bool> isIntrinsic,
       Scope *ancestor = nullptr);
 };
 
-class InterfaceVisitor : public virtual ScopeHandler {
+class GenericHandler : public virtual ScopeHandler {
+protected:
+  using ProcedureKind = parser::ProcedureStmt::Kind;
+  void ResolveSpecificsInGeneric(Symbol &, bool isEndOfSpecificationPart);
+  void DeclaredPossibleSpecificProc(Symbol &);
+
+  // Mappings of generics to their as-yet specific proc names and kinds
+  using SpecificProcMapType =
+      std::multimap<Symbol *, std::pair<const parser::Name *, ProcedureKind>>;
+  SpecificProcMapType specificsForGenericProcs_;
+  // inversion of SpecificProcMapType: maps pending proc names to generics
+  using GenericProcMapType = std::multimap<SourceName, Symbol *>;
+  GenericProcMapType genericsForSpecificProcs_;
+};
+
+class InterfaceVisitor : public virtual ScopeHandler,
+                         public virtual GenericHandler {
 public:
   bool Pre(const parser::InterfaceStmt &);
   void Post(const parser::InterfaceStmt &);
   void Post(const parser::EndInterfaceStmt &);
   bool Pre(const parser::GenericSpec &);
   bool Pre(const parser::ProcedureStmt &);
   bool Pre(const parser::GenericStmt &);
   void Post(const parser::GenericStmt &);
GenericInfo(bool isInterface, bool isAbstract = false)
         : isInterface{isInterface}, isAbstract{isAbstract} {}
     bool isInterface; // in interface block
     bool isAbstract; // in abstract interface block
     Symbol *symbol{nullptr}; // the generic symbol being defined
   };
   std::stack<GenericInfo> genericInfo_;
   const GenericInfo &GetGenericInfo() const { return genericInfo_.top(); }
   void SetGenericSymbol(Symbol &symbol) { genericInfo_.top().symbol = &symbol; }
-
-  using ProcedureKind = parser::ProcedureStmt::Kind;
-  // mapping of generic to its specific proc names and kinds
-  using SpecificProcMapType =
-      std::multimap<Symbol *, std::pair<const parser::Name *, ProcedureKind>>;
-  SpecificProcMapType specificProcs_;
-
   void AddSpecificProcs(const std::list<parser::Name> &, ProcedureKind);
-  void ResolveSpecificsInGeneric(Symbol &, bool isEndOfSpecificationPart);
   void ResolveNewSpecifics();
 };
 
 class SubprogramVisitor : public virtual ScopeHandler, public InterfaceVisitor {
 public:
   bool HandleStmtFunction(const parser::StmtFunctionStmt &);
   bool Pre(const parser::SubroutineStmt &);
   bool Pre(const parser::FunctionStmt &);
private:
   void CreateEntry(const parser::EntryStmt &stmt, Symbol &subprogram);
   void PostEntryStmt(const parser::EntryStmt &stmt);
   void HandleLanguageBinding(Symbol *,
       std::optional<parser::CharBlock> stmtSource,
       const std::optional<parser::LanguageBindingSpec> *);
 };
 
 class DeclarationVisitor : public ArraySpecVisitor,
-                           public virtual ScopeHandler {
+                           public virtual GenericHandler {
 public:
   using ArraySpecVisitor::Post;
   using ScopeHandler::Post;
   using ScopeHandler::Pre;
 
   bool Pre(const parser::Initialization &);
   void Post(const parser::EntityDecl &);
   void Post(const parser::ObjectDecl &);
bool InterfaceVisitor::isGeneric() const {
   return !genericInfo_.empty() && GetGenericInfo().symbol;
 }
 bool InterfaceVisitor::isAbstract() const {
   return !genericInfo_.empty() && GetGenericInfo().isAbstract;
 }
 
 void InterfaceVisitor::AddSpecificProcs(
     const std::list<parser::Name> &names, ProcedureKind kind) {
+  if (Symbol * symbol{GetGenericInfo().symbol};
+      symbol && symbol->has<GenericDetails>()) {
     for (const auto &name : names) {
-    specificProcs_.emplace(
-        GetGenericInfo().symbol, std::make_pair(&name, kind));
+      specificsForGenericProcs_.emplace(symbol, std::make_pair(&name, kind));
+      genericsForSpecificProcs_.emplace(name.source, symbol);
+    }
   }
 }
 
 // By now we should have seen all specific procedures referenced by name in
 // this generic interface. Resolve those names to symbols.
-void InterfaceVisitor::ResolveSpecificsInGeneric(
+void GenericHandler::ResolveSpecificsInGeneric(
     Symbol &generic, bool isEndOfSpecificationPart) {
   auto &details{generic.get<GenericDetails>()};
   UnorderedSymbolSet symbolsSeen;
   for (const Symbol &symbol : details.specificProcs()) {
     symbolsSeen.insert(symbol.GetUltimate());
   }
-  auto range{specificProcs_.equal_range(&generic)};
+  auto range{specificsForGenericProcs_.equal_range(&generic)};
   SpecificProcMapType retain;
   for (auto it{range.first}; it != range.second; ++it) {
     const parser::Name *name{it->second.first};
     auto kind{it->second.second};
-    const Symbol *symbol{FindSymbol(*name)};
-    if (!isEndOfSpecificationPart && symbol &&
-        &symbol->owner() != &generic.owner()) {
-      // Don't mistakenly use a name from the enclosing scope while there's
-      // still a chance that it could be overridden by a later declaration in
-      // this scope.
-      retain.emplace(&generic, std::make_pair(name, kind));
-      continue;
-    }
+    const Symbol *symbol{isEndOfSpecificationPart
+            ? FindSymbol(*name)
+            : FindInScope(generic.owner(), *name)};
     ProcedureDefinitionClass defClass{ProcedureDefinitionClass::None};
     const Symbol *specific{symbol};
     const Symbol *ultimate{nullptr};
     if (symbol) {
       // Subtlety: when *symbol is a use- or host-association, the specific
       // procedure that is recorded in the GenericDetails below must be *symbol,
       // not the specific procedure shadowed by a generic, because that specific
       // procedure may be a symbol from another module and its name unavailable
if (error) {
           name->source, MakeOpName(generic.name()));
     } else {
       Say(name->source,
           "Procedure '%s' from module '%s' is already specified in generic '%s'"_err_en_US,
           ultimate->name(), ultimate->owner().GetName().value(),
           MakeOpName(generic.name()));
     }
   }
-  specificProcs_.erase(range.first, range.second);
-  specificProcs_.merge(std::move(retain));
+  specificsForGenericProcs_.erase(range.first, range.second);
+  specificsForGenericProcs_.merge(std::move(retain));
+}
+
+void GenericHandler::DeclaredPossibleSpecificProc(Symbol &proc) {
+  auto range{genericsForSpecificProcs_.equal_range(proc.name())};
+  for (auto iter{range.first}; iter != range.second; ++iter) {
+    ResolveSpecificsInGeneric(*iter->second, false);
+  }
 }
 
 void InterfaceVisitor::ResolveNewSpecifics() {
   if (Symbol * generic{genericInfo_.top().symbol};
       generic && generic->has<GenericDetails>()) {
     ResolveSpecificsInGeneric(*generic, false);
   }
 }
for (const auto &ref : *entryStmts) {
       const parser::EntryStmt &entryStmt{*ref};
       if (const auto &suffix{
               std::get<std::optional<parser::Suffix>>(entryStmt.t)}) {
         const auto &name{std::get<parser::Name>(entryStmt.t)};
         HandleLanguageBinding(name.symbol, name.source, &suffix->binding);
       }
     }
   }
+  if (inInterfaceBlock() && currScope().symbol()) {
+    DeclaredPossibleSpecificProc(*currScope().symbol());
+  }
   PopScope();
 }
 
 bool SubprogramVisitor::HandlePreviousCalls(
     const parser::Name &name, Symbol &symbol, Symbol::Flag subpFlag) {
   // If the extant symbol is a generic, check its homonymous specific
   // procedure instead if it has one.
   if (auto *generic{symbol.detailsIf<GenericDetails>()}) {
if (!dtDetails) {
     attrs.set(Attr::EXTERNAL);
   }
   Symbol &symbol{DeclareProcEntity(name, attrs, procInterface)};
   SetCUDADataAttr(name.source, symbol, cudaDataAttr()); // for error
   symbol.ReplaceName(name.source);
   if (dtDetails) {
     dtDetails->add_component(symbol);
   }
+  DeclaredPossibleSpecificProc(symbol);
 }
 
 bool DeclarationVisitor::Pre(const parser::TypeBoundProcedurePart &) {
   derivedTypeInfo_.sawContains = true;
   return true;
 }
 
 // Resolve binding names from type-bound generics, saved in genericBindings_.

flang/test/Semantics/symbol29.f90

+! RUN: %python %S/test_symbols.py %s %flang_fc1
+! References to generic functions with forward-referenced specifics.
+!DEF: /m Module
+module m
+contains
+ !DEF: /m/specific4 PUBLIC (Function) Subprogram INTEGER(4)
+ !DEF: /m/specific4/x INTENT(IN) ObjectEntity INTEGER(4)
+ integer function specific4(x)
+  !REF: /m/specific4/x
+  integer, intent(in) :: x(*)
+ end function
+ !DEF: /m/test PUBLIC (Subroutine) Subprogram
+ !DEF: /m/test/specific1 EXTERNAL (Function) Subprogram INTEGER(4)
+ subroutine test (specific1)
+  !DEF: /m/test/generic (Function) Generic
+  interface generic
+   !REF: /m/test/specific1
+   procedure :: specific1
+   !DEF: /m/test/specific2 EXTERNAL, PURE (Function) Subprogram INTEGER(4)
+   procedure :: specific2
+   !DEF: /m/test/specific3 EXTERNAL (Function) Subprogram INTEGER(4)
+   procedure :: specific3
+   !DEF: /m/test/specific4 EXTERNAL (Function) Subprogram INTEGER(4)
+   procedure :: specific4
+  end interface
+  interface
+   !REF: /m/test/specific1
+   !DEF: /m/test/specific1/x INTENT(IN) ObjectEntity INTEGER(4)
+   integer function specific1(x)
+    !REF: /m/test/specific1/x
+    integer, intent(in) :: x
+   end function
+   !REF: /m/test/specific2
+   !DEF: /m/test/specific2/x INTENT(IN) ObjectEntity INTEGER(4)
+   !DEF: /m/test/specific2/y INTENT(IN) ObjectEntity INTEGER(4)
+   pure integer function specific2(x, y)
+    !REF: /m/test/specific2/x
+    !REF: /m/test/specific2/y
+    integer, intent(in) :: x, y
+   end function
+   !REF: /m/test/specific3
+   !DEF: /m/test/specific3/x INTENT(IN) ObjectEntity INTEGER(4)
+   !DEF: /m/test/specific3/y INTENT(IN) ObjectEntity INTEGER(4)
+   integer function specific3(x, y)
+    !REF: /m/test/generic
+    import :: generic
+    !REF: /m/test/specific3/x
+    !REF: /m/test/specific3/y
+    !REF: /m/test/specific2
+    integer, intent(in) :: x, y(generic(1, x))
+   end function
+   !REF: /m/test/specific4
+   !DEF: /m/test/specific4/x INTENT(IN) ObjectEntity INTEGER(4)
+   integer function specific4(x)
+    !REF: /m/test/specific4/x
+    integer, intent(in) :: x(:)
+   end function
+  end interface
+  !REF: /m/test/specific4
+  print *, generic([1])
+ end subroutine
+end module