[flang] Handle module subprogram with interface in same (sub)module when writing module file

[klausler]

Summary

There's a few (3) cases where Fortran allows two distinct symbols to have
the same name in the same scope. Module file output copes with only two of
them. The third involves a separate module procedure that isn't separate:
both the procedure and its declared interface appear in the same (sub)module.
Fix to ensure that the interface is included in the module file output, so
that the module file reader doesn't suffer a bogus error about a "separate
module procedure without an interface".

flang/lib/Semantics/mod-file.cpp

void ModFileWriter::PutDECStructure(
   decls_ << "end structure\n";
 }
 
 // Attributes that may be in a subprogram prefix
 static const Attrs subprogramPrefixAttrs{Attr::ELEMENTAL, Attr::IMPURE,
     Attr::MODULE, Attr::NON_RECURSIVE, Attr::PURE, Attr::RECURSIVE};
 
 void ModFileWriter::PutSubprogram(const Symbol &symbol) {
-  auto attrs{symbol.attrs()};
   auto &details{symbol.get<SubprogramDetails>()};
+  if (const Symbol * interface{details.moduleInterface()}) {
+    PutSubprogram(*interface);
+  }
+  auto attrs{symbol.attrs()};
   Attrs bindAttrs{};
   if (attrs.test(Attr::BIND_C)) {
     // bind(c) is a suffix, not prefix
     bindAttrs.set(Attr::BIND_C, true);
     attrs.set(Attr::BIND_C, false);
   }
   bool isAbstract{attrs.test(Attr::ABSTRACT)};
   if (isAbstract) {
if (const auto *useDetails{symbol.detailsIf<UseDetails>()}) {
       bool needed{useSet_.count(ultimate) > 0};
       if (const auto *generic{ultimate.detailsIf<GenericDetails>()}) {
         // The generic may not be needed itself, but the specific procedure
         // &/or derived type that it shadows may be needed.
         const Symbol *spec{generic->specific()};
         const Symbol *dt{generic->derivedType()};
         needed = needed || (spec && useSet_.count(*spec) > 0) ||
             (dt && useSet_.count(*dt) > 0);
+      } else if (const auto *subp{ultimate.detailsIf<SubprogramDetails>()}) {
+        const Symbol *interface { subp->moduleInterface() };
+        needed = needed || (interface && useSet_.count(*interface) > 0);
       }
       if (needed) {
         need_.push_back(symbol);
       }
     } else if (symbol.has<SubprogramDetails>()) {
       // An internal subprogram is needed if it is used as interface
       // for a dummy or return value procedure.
       bool needed{false};