[flang] Allow reference to earlier generic in later interface

[klausler]

Summary

Name resolutions defers all resolution and checking of specific procedures
in non-type-bound generic interfaces to the end of the specification part.
This prevents expression analysis of references to generic functions in
specification expressions in interfaces from resolving.

Example (now a new test case in modfile07.f90):

module m12
  interface generic
    module procedure specific
  end interface
  interface
    module subroutine s(a1,a2)
      character(*) a1
      character(generic(a1)) a2   ! <--
    end
  end interface
 contains
  pure integer function specific(x)
    character(*), intent(in) :: x
    specific = len(x)
  end
end

The solution is to partially resolve specific procedures as they are
defined for each generic, when they can be resolved, with the final
pass at the end of the specification part to finish up any forward
references and emit the necessary error messages.

Making this fix caused some issues in module file output, which have
all been resolved by making this simplifying change: generics are
now all emitted to module file specification parts as their own
group of declarations at the end of the specification part,
followed only by namelists and COMMON blocks.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Semantics/mod-file.cpp

common::visit(
             if (symbol.owner().IsDerivedType()) {
               // generic binding
               for (const Symbol &proc : x.specificProcs()) {
                 PutGenericName(typeBindings << "generic::", symbol)
                     << "=>" << proc.name() << '\n';
               }
             } else {
               PutGeneric(symbol);
-              if (x.specific() && &x.specific()->owner() == &symbol.owner()) {
-                PutSymbol(typeBindings, *x.specific());
-              }
-              if (x.derivedType() &&
-                  &x.derivedType()->owner() == &symbol.owner()) {
-                PutSymbol(typeBindings, *x.derivedType());
-              }
             }
           },
           [&](const UseDetails &) { PutUse(symbol); },
           [](const UseErrorDetails &) {},
           [&](const ProcBindingDetails &x) {
             bool deferred{symbol.attrs().test(Attr::DEFERRED)};
             typeBindings << "procedure";
             if (deferred) {

 void ModFileWriter::PutUseExtraAttr(
     Attr attr, const Symbol &local, const Symbol &use) {
   if (local.attrs().test(attr) && !use.attrs().test(attr)) {
     PutAttr(useExtraAttrs_, attr) << "::";
     useExtraAttrs_ << local.name() << '\n';
   }
 }
 
-// When a generic interface has the same name as a derived type
-// in the same scope, the generic shadows the derived type.
-// If the derived type were declared first, emit the generic
-// interface at the position of derived type's declaration.
-// (ReplaceName() is not used for this purpose because doing so
-// would confusingly position error messages pertaining to the generic
-// interface upon the derived type's declaration.)
 static inline SourceName NameInModuleFile(const Symbol &symbol) {
-  if (const auto *generic{symbol.detailsIf<GenericDetails>()}) {
-    if (const auto *derivedTypeOverload{generic->derivedType()}) {
-      if (derivedTypeOverload->name().begin() < symbol.name().begin()) {
-        return derivedTypeOverload->name();
-      }
-    }
-  } else if (const auto *use{symbol.detailsIf<UseDetails>()}) {
+  if (const auto *use{symbol.detailsIf<UseDetails>()}) {
     if (use->symbol().attrs().test(Attr::PRIVATE)) {
       // Avoid the use in sorting of names created to access private
       // specific procedures as a result of generic resolution;
       // they're not in the cooked source.
       return use->symbol().name();
     }
   }
   return symbol.name();
 }
 
 // Collect the symbols of this scope sorted by their original order, not name.
-// Namelists are an exception: they are sorted after other symbols.
+// Generics and namelists are exceptions: they are sorted after other symbols.
 void CollectSymbols(
     const Scope &scope, SymbolVector &sorted, SymbolVector &uses) {
-  SymbolVector namelist;
+  SymbolVector namelist, generics;
   std::size_t commonSize{scope.commonBlocks().size()};
   auto symbols{scope.GetSymbols()};
   sorted.reserve(symbols.size() + commonSize);
   for (SymbolRef symbol : symbols) {
     if (!symbol->test(Symbol::Flag::ParentComp)) {
       if (symbol->has<NamelistDetails>()) {
         namelist.push_back(symbol);
+      } else if (const auto *generic{symbol->detailsIf<GenericDetails>()}) {
+        if (generic->specific() &&
+            &generic->specific()->owner() == &symbol->owner()) {
+          sorted.push_back(*generic->specific());
+        } else if (generic->derivedType() &&
+            &generic->derivedType()->owner() == &symbol->owner()) {
+          sorted.push_back(*generic->derivedType());
+        }
+        generics.push_back(symbol);
       } else {
         sorted.push_back(symbol);
       }
       if (const auto *details{symbol->detailsIf<GenericDetails>()}) {
         uses.insert(uses.end(), details->uses().begin(), details->uses().end());
       }
     }
   }
   // Sort most symbols by name: use of Symbol::ReplaceName ensures the source
   // location of a symbol's name is the first "real" use.
-  std::sort(sorted.begin(), sorted.end(), [](SymbolRef x, SymbolRef y) {
-    return NameInModuleFile(x).begin() < NameInModuleFile(y).begin();
-  });
+  auto sorter{[](SymbolRef x, SymbolRef y) {
+    return NameInModuleFile(*x).begin() < NameInModuleFile(*y).begin();
+  }};
+  std::sort(sorted.begin(), sorted.end(), sorter);
+  std::sort(generics.begin(), generics.end(), sorter);
+  sorted.insert(sorted.end(), generics.begin(), generics.end());
   sorted.insert(sorted.end(), namelist.begin(), namelist.end());
   for (const auto &pair : scope.commonBlocks()) {
     sorted.push_back(*pair.second);
   }
   std::sort(
       sorted.end() - commonSize, sorted.end(), SymbolSourcePositionCompare{});
 }
 

flang/lib/Semantics/resolve-names.cpp

struct GenericInfo {
     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
-  std::multimap<Symbol *, std::pair<const parser::Name *, ProcedureKind>>
-      specificProcs_;
+  using SpecificProcMapType =
+      std::multimap<Symbol *, std::pair<const parser::Name *, ProcedureKind>>;
+  SpecificProcMapType specificProcs_;
 
   void AddSpecificProcs(const std::list<parser::Name> &, ProcedureKind);
-  void ResolveSpecificsInGeneric(Symbol &generic);
+  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 &);
   void Post(const parser::FunctionStmt &);
bool InterfaceVisitor::Pre(const parser::InterfaceStmt &x) {
   bool isAbstract{std::holds_alternative<parser::Abstract>(x.u)};
   genericInfo_.emplace(/*isInterface*/ true, isAbstract);
   return BeginAttrs();
 }
 
 void InterfaceVisitor::Post(const parser::InterfaceStmt &) { EndAttrs(); }
 
 void InterfaceVisitor::Post(const parser::EndInterfaceStmt &) {
+  ResolveNewSpecifics();
   genericInfo_.pop();
 }
 
 // Create a symbol in genericSymbol_ for this GenericSpec.
 bool InterfaceVisitor::Pre(const parser::GenericSpec &x) {
   if (auto *symbol{FindInScope(GenericSpecInfo{x}.symbolName())}) {
     SetGenericSymbol(*symbol);
   }
   if (const auto *opr{std::get_if<parser::DefinedOperator>(&x.u)}; opr &&
       std::holds_alternative<parser::DefinedOperator::IntrinsicOperator>(
           opr->u)) {
     context().set_anyDefinedIntrinsicOperator(true);
   }
   return false;
 }
 
 bool InterfaceVisitor::Pre(const parser::ProcedureStmt &x) {
   if (!isGeneric()) {
     Say("A PROCEDURE statement is only allowed in a generic interface block"_err_en_US);
-    return false;
-  }
+  } else {
     auto kind{std::get<parser::ProcedureStmt::Kind>(x.t)};
     const auto &names{std::get<std::list<parser::Name>>(x.t)};
     AddSpecificProcs(names, kind);
+  }
   return false;
 }
 
 bool InterfaceVisitor::Pre(const parser::GenericStmt &) {
   genericInfo_.emplace(/*isInterface*/ false);
   return true;
 }
 void InterfaceVisitor::Post(const parser::GenericStmt &x) {
   if (auto &accessSpec{std::get<std::optional<parser::AccessSpec>>(x.t)}) {
     SetExplicitAttr(*GetGenericInfo().symbol, AccessSpecToAttr(*accessSpec));
   }
   const auto &names{std::get<std::list<parser::Name>>(x.t)};
   AddSpecificProcs(names, ProcedureKind::Procedure);
+  ResolveNewSpecifics();
   genericInfo_.pop();
 }
 
 bool InterfaceVisitor::inInterfaceBlock() const {
   return !genericInfo_.empty() && GetGenericInfo().isInterface;
 }
 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) {
   for (const auto &name : names) {
     specificProcs_.emplace(
         GetGenericInfo().symbol, std::make_pair(&name, kind));
   }
 }
 
 // By now we should have seen all specific procedures referenced by name in
 // this generic interface. Resolve those names to symbols.
-void InterfaceVisitor::ResolveSpecificsInGeneric(Symbol &generic) {
+void InterfaceVisitor::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)};
+  SpecificProcMapType retain;
   for (auto it{range.first}; it != range.second; ++it) {
     const parser::Name *name{it->second.first};
     auto kind{it->second.second};
-    const auto *symbol{FindSymbol(*name)};
-    if (!symbol) {
-      Say(*name, "Procedure '%s' not found"_err_en_US);
+    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;
     }
+    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 to
-    // emit to a module file.
+      // procedure may be a symbol from another module and its name unavailable
+      // to emit to a module file.
       const Symbol &bypassed{BypassGeneric(*symbol)};
-    const Symbol &specific{
-        symbol == &symbol->GetUltimate() ? bypassed : *symbol};
-    const Symbol &ultimate{bypassed.GetUltimate()};
-    ProcedureDefinitionClass defClass{ClassifyProcedure(ultimate)};
+      if (symbol == &symbol->GetUltimate()) {
+        specific = &bypassed;
+      }
+      ultimate = &bypassed.GetUltimate();
+      defClass = ClassifyProcedure(*ultimate);
+    }
+    std::optional<MessageFixedText> error;
     if (defClass == ProcedureDefinitionClass::Module) {
       // ok
     } else if (kind == ProcedureKind::ModuleProcedure) {
-      Say(*name, "'%s' is not a module procedure"_err_en_US);
-      continue;
+      error = "'%s' is not a module procedure"_err_en_US;
     } else {
       switch (defClass) {
       case ProcedureDefinitionClass::Intrinsic:
       case ProcedureDefinitionClass::External:
       case ProcedureDefinitionClass::Internal:
       case ProcedureDefinitionClass::Dummy:
       case ProcedureDefinitionClass::Pointer:
         break;
       case ProcedureDefinitionClass::None:
-        Say(*name, "'%s' is not a procedure"_err_en_US);
-        continue;
+        error = "'%s' is not a procedure"_err_en_US;
+        break;
       default:
-        Say(*name,
-            "'%s' is not a procedure that can appear in a generic interface"_err_en_US);
-        continue;
+        error =
+            "'%s' is not a procedure that can appear in a generic interface"_err_en_US;
+        break;
       }
     }
-    if (symbolsSeen.insert(ultimate).second /*true if added*/) {
+    if (error) {
+      if (isEndOfSpecificationPart) {
+        Say(*name, std::move(*error));
+      } else {
+        // possible forward reference, catch it later
+        retain.emplace(&generic, std::make_pair(name, kind));
+      }
+    } else if (!ultimate) {
+    } else if (symbolsSeen.insert(*ultimate).second /*true if added*/) {
       // When a specific procedure is a USE association, that association
       // is saved in the generic's specifics, not its ultimate symbol,
       // so that module file output of interfaces can distinguish them.
-      details.AddSpecificProc(specific, name->source);
-    } else if (&specific == &ultimate) {
+      details.AddSpecificProc(*specific, name->source);
+    } else if (specific == ultimate) {
       Say(name->source,
           "Procedure '%s' is already specified in generic '%s'"_err_en_US,
           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(),
+          ultimate->name(), ultimate->owner().GetName().value(),
           MakeOpName(generic.name()));
     }
   }
   specificProcs_.erase(range.first, range.second);
+  specificProcs_.merge(std::move(retain));
+}
+
+void InterfaceVisitor::ResolveNewSpecifics() {
+  if (Symbol * generic{genericInfo_.top().symbol};
+      generic && generic->has<GenericDetails>()) {
+    ResolveSpecificsInGeneric(*generic, false);
+  }
 }
 
 // Mixed interfaces are allowed by the standard.
 // If there is a derived type with the same name, they must all be functions.
 void InterfaceVisitor::CheckGenericProcedures(Symbol &generic) {
-  ResolveSpecificsInGeneric(generic);
+  ResolveSpecificsInGeneric(generic, true);
   auto &details{generic.get<GenericDetails>()};
   if (auto *proc{details.CheckSpecific()}) {
-    auto msg{
-        "'%s' should not be the name of both a generic interface and a"
-        " procedure unless it is a specific procedure of the generic"_warn_en_US};
-    if (proc->name().begin() > generic.name().begin()) {
-      Say(proc->name(), std::move(msg));
-    } else {
-      Say(generic.name(), std::move(msg));
-    }
+    Say(proc->name().begin() > generic.name().begin() ? proc->name()
+                                                      : generic.name(),
+        "'%s' should not be the name of both a generic interface and a procedure unless it is a specific procedure of the generic"_warn_en_US);
   }
   auto &specifics{details.specificProcs()};
   if (specifics.empty()) {
     if (details.derivedType()) {
       generic.set(Symbol::Flag::Function);
     }
     return;
   }

flang/test/Semantics/modfile07.f90

logical function s3(x,y)
     logical, intent(in) :: x,y
   end function
   integer function s4(x,y)
     integer, intent(in) :: x,y
   end function
 end
 !Expect: m1.mod
 !module m1
-! interface foo
-!  procedure::s1
-!  procedure::s2
-! end interface
 ! interface
 !  function s1(x,y)
 !   real(4),intent(in)::x
 !   logical(4),intent(in)::y
 !   real(4)::s1
 !  end
 ! end interface
 ! interface
 !  function s2(x,y)
 !   complex(4),intent(in)::x
 !   logical(4),intent(in)::y
 !   complex(4)::s2
 !  end
 ! end interface
-! interface operator(+)
-!  procedure::s1
-!  procedure::s2
-! end interface
-! interface operator(/=)
-!  procedure::f1
-!  procedure::f2
-!  procedure::f3
-! end interface
-! private::operator(/=)
 ! interface
 !  function f1(x,y)
 !   real(4),intent(in)::x
 !   logical(4),intent(in)::y
 !   logical(4)::f1
 !  end
 ! end interface
 ! interface
 !  function f2(x,y)
 !   complex(4),intent(in)::x
 !   logical(4),intent(in)::y
 !   logical(4)::f2
 !  end
 ! end interface
 ! interface
 !  function f3(x,y)
 !   integer(4),intent(in)::x
 !   logical(4),intent(in)::y
 !   logical(4)::f3
 !  end
 ! end interface
+! interface foo
+!  procedure::s1
+!  procedure::s2
+! end interface
+! interface operator(+)
+!  procedure::s1
+!  procedure::s2
+! end interface
+! interface operator(/=)
+!  procedure::f1
+!  procedure::f2
+!  procedure::f3
+! end interface
+! private::operator(/=)
 ! interface bar
 !  procedure::s1
 !  procedure::s2
 !  procedure::s3
 !  procedure::s4
 ! end interface
 ! interface operator(.bar.)
 !  procedure::s1
module m2b
   interface foo
   end interface
   private :: bar
   interface bar
   end interface
 end
 !Expect: m2b.mod
 !module m2b
-! interface foo
-! end interface
 ! type::foo
 !  real(4)::x
 ! end type
+! interface foo
+! end interface
 ! interface bar
 ! end interface
 ! private::bar
 !end
 
 ! Test interface nested inside another interface
 module m3
   interface g
     subroutine s1(f)
       interface
         real function f(x)
           interface
             subroutine x()
             end subroutine
           end interface
         end function
       end interface
     end subroutine
   end interface
 end
 !Expect: m3.mod
 !module m3
-! interface g
-!  procedure::s1
-! end interface
 ! interface
 !  subroutine s1(f)
 !   interface
 !    function f(x)
 !     interface
 !      subroutine x()
 !      end
 !     end interface
 !     real(4)::f
 !    end
 !   end interface
 !  end
 ! end interface
+! interface g
+!  procedure::s1
+! end interface
 !end
 
 module m4
   interface foo
     integer function foo()
     end function
     integer function f(x)
     end function
   end interface
 end
 subroutine s4
   use m4
   i = foo()
 end
 !Expect: m4.mod
 !module m4
-! interface foo
-!  procedure::foo
-!  procedure::f
-! end interface
 ! interface
 !  function foo()
 !   integer(4)::foo
 !  end
 ! end interface
 ! interface
 !  function f(x)
 !   real(4)::x
 !   integer(4)::f
 !  end
 ! end interface
+! interface foo
+!  procedure::foo
+!  procedure::f
+! end interface
 !end
 
 ! Compile contents of m4.mod and verify it gets the same thing again.
 module m5
  interface foo
   procedure::foo
   procedure::f
  end interface
  interface
   function foo()
    integer(4)::foo
   end
  end interface
  interface
   function f(x)
    integer(4)::f
    real(4)::x
   end
  end interface
 end
 !Expect: m5.mod
 !module m5
-! interface foo
-!  procedure::foo
-!  procedure::f
-! end interface
 ! interface
 !  function foo()
 !   integer(4)::foo
 !  end
 ! end interface
 ! interface
 !  function f(x)
 !   real(4)::x
 !   integer(4)::f
 !  end
 ! end interface
+! interface foo
+!  procedure::foo
+!  procedure::f
+! end interface
 !end
 
 module m6a
   interface operator(<)
     logical function lt(x, y)
       logical, intent(in) :: x, y
     end function
   end interface
 end
 !Expect: m6a.mod
 !module m6a
-! interface operator(<)
-!  procedure::lt
-! end interface
 ! interface
 !  function lt(x,y)
 !   logical(4),intent(in)::x
 !   logical(4),intent(in)::y
 !   logical(4)::lt
 !  end
 ! end interface
+! interface operator(<)
+!  procedure::lt
+! end interface
 !end
 
 module m6b
   use m6a, only: operator(.lt.)
 end
 !Expect: m6b.mod
 !module m6b
 ! use m6a,only:operator(.lt.)
 !end
 
 module m7a
   interface g_integer
     module procedure s
   end interface
   private :: s
 contains
   subroutine s(x)
     integer :: x
   end
 end
 !Expect: m7a.mod
 !module m7a
+! private :: s
 ! interface g_integer
 !  procedure :: s
 ! end interface
-! private :: s
 !contains
 ! subroutine s(x)
 !  integer(4) :: x
 ! end
 !end
 
 module m7b
   interface g_real
     module procedure s
   end interface
   private :: s
 contains
   subroutine s(x)
     real :: x
   end subroutine
 end
 !Expect: m7b.mod
 !module m7b
+! private :: s
 ! interface g_real
 !  procedure :: s
 ! end interface
-! private :: s
 !contains
 ! subroutine s(x)
 !  real(4) :: x
 ! end
 !end
 
 module m7c
   use m7a, only: g => g_integer
subroutine test()
     call g(y)
     call g(z)
   end
 end
 !Expect: m7c.mod
 !module m7c
 ! use m7a, only: g => g_integer
 ! use m7b, only: g => g_real
+! private :: s
 ! interface g
 !  procedure :: s
 ! end interface
-! private :: s
 !contains
 ! subroutine s(x)
 !  complex(4) :: x
 ! end
 ! subroutine test()
 ! end
 !end
 
 ! Test m8 is like m7 but without renaming.
 
 module m8a
   interface g
     module procedure s
   end interface
   private :: s
 contains
   subroutine s(x)
     integer :: x
   end
 end
 !Expect: m8a.mod
 !module m8a
+! private :: s
 ! interface g
 !  procedure :: s
 ! end interface
-! private :: s
 !contains
 ! subroutine s(x)
 !  integer(4) :: x
 ! end
 !end
 
 module m8b
   interface g
     module procedure s
   end interface
   private :: s
 contains
   subroutine s(x)
     real :: x
   end subroutine
 end
 !Expect: m8b.mod
 !module m8b
+! private :: s
 ! interface g
 !  procedure :: s
 ! end interface
-! private :: s
 !contains
 ! subroutine s(x)
 !  real(4) :: x
 ! end
 !end
 
 module m8c
   use m8a
subroutine test()
     call g(y)
     call g(z)
   end
 end
 !Expect: m8c.mod
 !module m8c
 ! use m8a, only: g
 ! use m8b, only: g
+! private :: s
 ! interface g
 !  procedure :: s
 ! end interface
-! private :: s
 !contains
 ! subroutine s(x)
 !  complex(4) :: x
 ! end
 ! subroutine test()
 ! end
 !end
 
 ! Merging a use-associated generic with a local generic
 
 module m9a
   interface g
     module procedure s
   end interface
   private :: s
 contains
   subroutine s(x)
     integer :: x
   end
 end
 !Expect: m9a.mod
 !module m9a
+! private :: s
 ! interface g
 !  procedure :: s
 ! end interface
-! private :: s
 !contains
 ! subroutine s(x)
 !  integer(4) :: x
 ! end
 !end
 
 module m9b
   use m9a
   interface g
     module procedure s
   end interface
   private :: s
 contains
   subroutine s(x)
     real :: x
   end
   subroutine test()
     call g(1)
     call g(1.0)
   end
 end
 !Expect: m9b.mod
 !module m9b
 ! use m9a,only:g
+! private::s
 ! interface g
 !   procedure::s
 ! end interface
-! private::s
 !contains
 ! subroutine s(x)
 !   real(4)::x
 ! end
 ! subroutine test()
 ! end
 !end
 

 end
 !Expect: m11b.mod
 !module m11b
 ! use m11a,only:s1
 ! interface g
 !  procedure::s1
 ! end interface
 !end
+
+module m12
+  interface generic
+    module procedure specific
+  end interface
+  interface
+    module subroutine s(a1,a2)
+      character(*) a1
+      character(generic(a1)) a2
+    end
+  end interface
+ contains
+  pure integer function specific(x)
+    character(*), intent(in) :: x
+    specific = len(x)
+  end
+end
+!Expect: m12.mod
+!module m12
+! interface
+!  module subroutine s(a1,a2)
+!   character(*,1)::a1
+!   character(specific(a1),1)::a2
+!  end
+! end interface
+! interface generic
+!  procedure::specific
+! end interface
+!contains
+! pure function specific(x)
+!  character(*,1),intent(in)::x
+!  integer(4)::specific
+! end
+!end

flang/test/Semantics/modfile32.f90

subroutine s3(x, y, z, w)
     real :: w(f(x, y, z))  ! resolves to f3
   end
   subroutine s4(x, y, z, w, u)
     real :: u(f(x, y, z, w))  ! resolves to f3
   end
 end
 !Expect: m1.mod
 !module m1
-! interface f
-!  procedure :: f1
-!  procedure :: f2
-!  procedure :: f3
-! end interface
 ! interface
 !  pure function f1(x)
 !   real(4), intent(in) :: x
 !   integer(8) :: f1
 !  end
 ! end interface
 ! interface
 !  pure function f2(x, y)
 !   real(4), intent(in) :: x
 !   real(4), intent(in) :: y
 !   integer(8) :: f2
 !  end
 ! end interface
 ! interface
 !  pure function f3(x, y, z, w)
 !   real(4), intent(in) :: x
 !   real(4), intent(in) :: y
 !   real(4), intent(in) :: z
 !   real(4), intent(in), optional :: w
 !   integer(8) :: f3
 !  end
 ! end interface
+! interface f
+!  procedure :: f1
+!  procedure :: f2
+!  procedure :: f3
+! end interface
 !contains
 ! subroutine s1(x, z)
 !  real(4) :: x
 !  real(4) :: z(1_8:f1(x))
 ! end
 ! subroutine s2(x, y, z)
 !  real(4) :: x
 !  real(4) :: y
contains
   end
   subroutine s3(x, y)
     integer :: x
     real :: y(f(x))  ! resolves to f_integer
   end
 end
 !Expect: m2.mod
 !module m2
-! interface f
-!  procedure :: f_real4
-!  procedure :: f_real8
-!  procedure :: f_integer
-! end interface
 ! interface
 !  pure function f_real4(x)
 !   real(4), intent(in) :: x
 !   integer(8) :: f_real4
 !  end
 ! end interface
 ! interface
 !  pure function f_real8(x)
 !   real(8), intent(in) :: x
 !   integer(8) :: f_real8
 !  end
 ! end interface
 ! interface
 !  pure function f_integer(x)
 !   integer(4), intent(in) :: x
 !   integer(8) :: f_integer
 !  end
 ! end interface
+! interface f
+!  procedure :: f_real4
+!  procedure :: f_real8
+!  procedure :: f_integer
+! end interface
 !contains
 ! subroutine s1(x, y)
 !  real(4) :: x
 !  real(4) :: y(1_8:f_real4(x))
 ! end
 ! subroutine s2(x, y)
 !  real(8) :: x
 !  real(4) :: y(1_8:f_real8(x))
contains
   end
   subroutine s2(x, y)
     integer :: x
     real :: y(.foo. x)  ! resolves to f_integer
   end
 end
 !Expect: m4.mod
 !module m4
-! interface operator(.foo.)
-!  procedure :: f_real
-!  procedure :: f_integer
-! end interface
 ! interface
 !  pure function f_real(x)
 !   real(4), intent(in) :: x
 !   integer(8) :: f_real
 !  end
 ! end interface
 ! interface
 !  pure function f_integer(x)
 !   integer(4), intent(in) :: x
 !   integer(8) :: f_integer
 !  end
 ! end interface
+! interface operator(.foo.)
+!  procedure :: f_real
+!  procedure :: f_integer
+! end interface
 !contains
 ! subroutine s1(x, y)
 !  real(4) :: x
 !  real(4) :: y(1_8:f_real(x))
 ! end
 ! subroutine s2(x, y)
 !  integer(4) :: x
 !  real(4) :: y(1_8:f_integer(x))
contains
   end
   subroutine s2(x, y)
     real :: x
     real :: y(1.0 .foo. x)  ! resolves to f1
   end
 end
 !Expect: m5.mod
 !module m5
-! interface operator(.foo.)
-!  procedure :: f1
-!  procedure :: f2
-! end interface
 ! interface
 !  pure function f1(x, y)
 !   real(4), intent(in) :: x
 !   real(4), intent(in) :: y
 !   integer(8) :: f1
 !  end
 ! end interface
 ! interface
 !  pure function f2(x, y)
 !   real(4), intent(in) :: x
 !   complex(4), intent(in) :: y
 !   integer(8) :: f2
 !  end
 ! end interface
+! interface operator(.foo.)
+!  procedure :: f1
+!  procedure :: f2
+! end interface
 !contains
 ! subroutine s1(x, y)
 !  complex(4) :: x
 !  real(4) :: y(1_8:f2(1._4, x))
 ! end
 ! subroutine s2(x, y)
 !  real(4) :: x
 !  real(4) :: y(1_8:f1(1._4, x))
 ! end
 !end

flang/test/Semantics/modfile33.f90

 end
 
 !Expect: m1.mod
 !module m1
 ! type :: t
 !  sequence
 !  logical(4) :: x
 ! end type
-! interface operator(+)
-!  procedure :: add_ll
-!  procedure :: add_li
-!  procedure :: add_tt
-! end interface
 ! interface
 !  pure function add_ll(x, y)
 !   logical(4), intent(in) :: x
 !   logical(4), intent(in) :: y
 !   integer(8) :: add_ll
 !  end
 ! end interface
 ! interface
 !  pure function add_li(x, y)
 !   logical(4), intent(in) :: x
 !   integer(4), intent(in) :: y
 !   integer(8) :: add_li
 !  end
 ! end interface
 ! interface
 !  pure function add_tt(x, y)
 !   import :: t
 !   type(t), intent(in) :: x
 !   type(t), intent(in) :: y
 !   integer(8) :: add_tt
 !  end
 ! end interface
-! interface operator(/)
-!  procedure :: div_tz
-!  procedure :: div_ct
-! end interface
 ! interface
 !  pure function div_tz(x, y)
 !   import :: t
 !   type(t), intent(in) :: x
 !   complex(4), intent(in) :: y
 !   integer(8) :: div_tz
 !  end
 ! end interface
 ! interface
 !  pure function div_ct(x, y)
 !   import :: t
 !   character(10_4, 1), intent(in) :: x
 !   type(t), intent(in) :: y
 !   integer(8) :: div_ct
 !  end
 ! end interface
+! interface operator(+)
+!  procedure :: add_ll
+!  procedure :: add_li
+!  procedure :: add_tt
+! end interface
+! interface operator(/)
+!  procedure :: div_tz
+!  procedure :: div_ct
+! end interface
 !contains
 ! subroutine s1(x, y, z)
 !  logical(4) :: x
 !  logical(4) :: y
 !  real(4) :: z(1_8:add_ll(x, y))
 ! end
 ! subroutine s2(x, y, z)
 !  logical(4) :: x

 end
 
 !Expect: m2.mod
 !module m2
 ! type :: t
 !  sequence
 !  logical(4) :: x
 ! end type
-! interface operator( .and.)
-!  procedure :: and_ti
-!  procedure :: and_li
-!  procedure :: and_tt
-! end interface
 ! interface
 !  pure function and_ti(x, y)
 !   import :: t
 !   type(t), intent(in) :: x
 !   integer(4), intent(in) :: y
 !   integer(8) :: and_ti
 !  end
 ! end interface
 ! interface
 !  pure function and_li(x, y)
 !   logical(4), intent(in) :: x
 !   integer(4), intent(in) :: y
 !   integer(8) :: and_li
 !  end
 ! end interface
 ! interface
 !  pure function and_tt(x, y)
 !   import :: t
 !   type(t), intent(in) :: x
 !   type(t), intent(in) :: y
 !   integer(8) :: and_tt
 !  end
 ! end interface
-! interface operator(.x.)
-!  procedure :: neqv_tt
-!  procedure :: neqv_rr
-! end interface
 ! interface
 !  pure function neqv_tt(x, y)
 !   import :: t
 !   type(t), intent(in) :: x
 !   type(t), intent(in) :: y
 !   integer(8) :: neqv_tt
 !  end
 ! end interface
 ! interface
 !  pure function neqv_rr(x, y)
 !   real(4), intent(in) :: x
 !   real(4), intent(in) :: y
 !   integer(8) :: neqv_rr
 !  end
 ! end interface
+! interface operator( .and.)
+!  procedure :: and_ti
+!  procedure :: and_li
+!  procedure :: and_tt
+! end interface
+! interface operator(.x.)
+!  procedure :: neqv_tt
+!  procedure :: neqv_rr
+! end interface
 !contains
 ! subroutine s1(x, y, z)
 !  type(t) :: x
 !  integer(4) :: y
 !  real(4) :: z(1_8:and_ti(x, y))
 ! end
 ! subroutine s2(x, y, z)
 !  logical(4) :: x

 end
 
 !Expect: m3.mod
 !module m3
 ! type :: t
 !  sequence
 !  logical(4) :: x
 ! end type
-! interface operator(<>)
-!  procedure :: ne_it
-!  procedure :: ne_tt
-!  procedure :: ne_ci
-! end interface
 ! interface
 !  pure function ne_it(x, y)
 !   import :: t
 !   integer(4), intent(in) :: x
 !   type(t), intent(in) :: y
 !   integer(8) :: ne_it
 !  end
 ! end interface
 ! interface
 !  pure function ne_tt(x, y)
 !   import :: t
 !   type(t), intent(in) :: x
 !   type(t), intent(in) :: y
 !   integer(8) :: ne_tt
 !  end
 ! end interface
 ! interface
 !  pure function ne_ci(x, y)
 !   character(*, 1), intent(in) :: x
 !   integer(4), intent(in) :: y
 !   integer(8) :: ne_ci
 !  end
 ! end interface
+! interface operator(<>)
+!  procedure :: ne_it
+!  procedure :: ne_tt
+!  procedure :: ne_ci
+! end interface
 !contains
 ! subroutine s1(x, y, z)
 !  integer(4) :: x
 !  type(t) :: y
 !  real(4) :: z(1_8:ne_it(x, y))
 ! end
 ! subroutine s2(x, y, z)
 !  type(t) :: x
contains
   end
 end
 !Expect: m4.mod
 !module m4
 ! type :: t
 !  sequence
 !  logical(4) :: x
 ! end type
-! interface operator(//)
-!  procedure :: concat_12
-!  procedure :: concat_int_real
-! end interface
 ! interface
 !  pure function concat_12(x, y)
 !   character(*, 1), intent(in) :: x
 !   character(*, 2), intent(in) :: y
 !   integer(8) :: concat_12
 !  end
 ! end interface
 ! interface
 !  pure function concat_int_real(x, y)
 !   integer(4), intent(in) :: x
 !   real(4), intent(in) :: y
 !   integer(8) :: concat_int_real
 !  end
 ! end interface
+! interface operator(//)
+!  procedure :: concat_12
+!  procedure :: concat_int_real
+! end interface
 !contains
 ! subroutine s1(x, y, z)
 !  character(*, 1) :: x
 !  character(*, 2) :: y
 !  real(4) :: z(1_8:concat_12(x, y))
 ! end
 ! subroutine s2(x, y, z)
 !  integer(4) :: x
subroutine s4(x, y)
     real :: y(.not. x)  ! resolves to not_real
   end
 end
 
 !Expect: m5.mod
 !module m5
 ! type :: t
 ! end type
-! interface operator(+)
-!  procedure :: plus_l
-! end interface
 ! interface
 !  pure function plus_l(x)
 !   logical(4), intent(in) :: x
 !   integer(8) :: plus_l
 !  end
 ! end interface
-! interface operator(-)
-!  procedure :: minus_t
-! end interface
 ! interface
 !  pure function minus_t(x)
 !   import :: t
 !   type(t), intent(in) :: x
 !   integer(8) :: minus_t
 !  end
 ! end interface
-! interface operator( .not.)
-!  procedure :: not_t
-!  procedure :: not_real
-! end interface
 ! interface
 !  pure function not_t(x)
 !   import :: t
 !   type(t), intent(in) :: x
 !   integer(8) :: not_t
 !  end
 ! end interface
 ! interface
 !  pure function not_real(x)
 !   real(4), intent(in) :: x
 !   integer(8) :: not_real
 !  end
 ! end interface
+! interface operator(+)
+!  procedure :: plus_l
+! end interface
+! interface operator(-)
+!  procedure :: minus_t
+! end interface
+! interface operator( .not.)
+!  procedure :: not_t
+!  procedure :: not_real
+! end interface
 !contains
 ! subroutine s1(x, y)
 !  logical(4) :: x
 !  real(4) :: y(1_8:plus_l(x))
 ! end
 ! subroutine s2(x, y)
 !  type(t) :: x
 !  real(4) :: y(1_8:minus_t(x))
subroutine s1(n, x, y, z, a, b)
     real :: z(2, 2, 2)
     real :: a(size(x+y))  ! intrinsic +
     real :: b(y+z)  ! resolves to add
   end
 end
 
 !Expect: m6.mod
 !module m6
-! interface operator(+)
-!  procedure :: add
-! end interface
 ! interface
 !  pure function add(x, y)
 !   real(4), intent(in) :: x(:, :)
 !   real(4), intent(in) :: y(:, :, :)
 !   integer(8) :: add
 !  end
 ! end interface
+! interface operator(+)
+!  procedure :: add
+! end interface
 !contains
 ! subroutine s1(n, x, y, z, a, b)
 !  integer(8) :: n
 !  real(4) :: x
 !  real(4) :: y(1_8:4_8, 1_8:n)
 !  real(4) :: z(1_8:2_8, 1_8:2_8, 1_8:2_8)
 !  real(4) :: a(1_8:int(int(4_8*size(y,dim=2,kind=8),kind=4),kind=8))
 !  real(4) :: b(1_8:add(y, z))

 end
 
 !Expect: m7.mod
 !module m7
 ! type :: t(k)
 !  integer(4), kind :: k
 !  real(int(int(k,kind=4),kind=8))::a
 ! end type
-! interface operator(+)
-!  procedure :: f1
-!  procedure :: f2
-! end interface
 ! interface
 !  pure function f1(x, y)
 !   import :: t
 !   type(t(k=4_4)), intent(in) :: x
 !   type(t(k=4_4)), intent(in) :: y
 !   integer(8) :: f1
 !  end
 ! end interface
 ! interface
 !  pure function f2(x, y)
 !   import :: t
 !   type(t(k=8_4)), intent(in) :: x
 !   type(t(k=8_4)), intent(in) :: y
 !   integer(8) :: f2
 !  end
 ! end interface
+! interface operator(+)
+!  procedure :: f1
+!  procedure :: f2
+! end interface
 !contains
 ! subroutine s1(x, y, z)
 !  type(t(k=4_4)) :: x
 !  type(t(k=4_4)) :: y
 !  real(4) :: z(1_8:f1(x, y))
 ! end
 ! subroutine s2(x, y, z)
 !  type(t(k=8_4)) :: x
 !  type(t(k=8_4)) :: y
 !  real(4) :: z(1_8:f2(x, y))
 ! end
 !end

flang/test/Semantics/modfile38.f90

module m
   end interface
  contains
   type(t) function f
   end function
 end module
 
 !Expect: m.mod
 !module m
-!interface t
-!procedure::f
-!end interface
 !type::t
 !end type
 !type::t2
 !type(t)::c
 !end type
+!interface t
+!procedure::f
+!end interface
 !contains
 !function f()
 !type(t)::f
 !end
 !end

flang/test/Semantics/modfile39.f90

  contains
   pure integer function priv(n)
     integer, intent(in) :: n
     priv = n
   end function
 end module
 !Expect: m1.mod
 !module m1
+!private::priv
 !interface gen
 !procedure::priv
 !end interface
-!private::priv
 !contains
 !pure function priv(n)
 !integer(4),intent(in)::n
 !integer(4)::priv
 !end
 !end
 
 module m2

flang/test/Semantics/modfile44.f90

function xzy(j) result(res)
     integer, intent(in) :: j
     type(xyz) :: res
     res%n = j
   end function
 end module
 
 !Expect: m1.mod
 !module m1
-!interface xyz
-!procedure::xzy
-!end interface
 !type::xyz
 !integer(4)::n
 !end type
+!interface xyz
+!procedure::xzy
+!end interface
 !contains
 !function xzy(j) result(res)
 !integer(4),intent(in)::j
 !type(xyz)::res
 !end
 !end
 
 module m2

flang/test/Semantics/resolve15.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1
 module m
   real :: var
   interface i
     !ERROR: 'var' is not a procedure
     procedure :: sub, var
-    !ERROR: Procedure 'bad' not found
+    !ERROR: 'bad' is not a procedure
     procedure :: bad
   end interface
   interface operator(.foo.)
     !ERROR: 'var' is not a procedure
     procedure :: var
     !ERROR: OPERATOR(.foo.) procedure 'sub' must be a function
     procedure :: sub
-    !ERROR: Procedure 'bad' not found
+    !ERROR: 'bad' is not a procedure
     procedure :: bad
   end interface
 contains
   subroutine sub
   end
 end
 
 subroutine s

flang/test/Semantics/resolve25.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1
 module m
   interface foo
     real function s1(x)
       real x
     end
     !ERROR: 's2' is not a module procedure
     module procedure s2
-    !ERROR: Procedure 's3' not found
+    !ERROR: 's3' is not a procedure
     procedure s3
     !ERROR: Procedure 's1' is already specified in generic 'foo'
     procedure s1
   end interface
   interface
     real function s4(x,y)
       real, intent(in) :: x,y
     end function

flang/test/Semantics/resolve77.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1
 ! Tests valid and invalid usage of forward references to procedures
 ! in specification expressions.
 module m
   interface ifn2
     module procedure if2
   end interface
   interface ifn3
     module procedure if3
   end interface
   !ERROR: Automatic data object 'a' may not appear in the specification part of a module
   real :: a(if1(1))
-  !ERROR: No specific function of generic 'ifn2' matches the actual arguments
+  !ERROR: Automatic data object 'b' may not appear in the specification part of a module
   real :: b(ifn2(1))
  contains
   subroutine t1(n)
     integer :: iarr(if1(n))
   end subroutine
   pure integer function if1(n)
     integer, intent(in) :: n
     if1 = n