[flang] Ensure USE associations of shadowed procedures are emitted to module files

[klausler]

Summary

When a generic interface in a module shadows a procedure of the same name that
has been brought into scope via USE association, ensure that that USE association is
not lost when the module file is written.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Semantics/resolve-names.cpp

if (useGeneric) {
       combine = true;
     } else if (useUltimate.has<DerivedTypeDetails>()) {
       if (checkAmbiguousDerivedType(
               &useUltimate, localGeneric->derivedType())) {
         combine = true;
       } else {
         return;
       }
-    } else if (&useUltimate == &BypassGeneric(localUltimate)) {
+    } else if (&useUltimate == &BypassGeneric(localUltimate).GetUltimate()) {
       return; // nothing to do; used subprogram is local's specific
     }
   } else if (useGeneric) {
     if (localUltimate.has<DerivedTypeDetails>()) {
       if (checkAmbiguousDerivedType(
               &localUltimate, useGeneric->derivedType())) {
         combine = true;
       } else {
if (isFunction != specific.test(Symbol::Flag::Function)) { // C1514
         msg.Attach(specific.name(), "Function declaration"_en_US);
       }
     }
   }
   if (!isFunction && details.derivedType()) {
     SayDerivedType(generic.name(),
         "Generic interface '%s' may only contain functions due to derived type"
         " with same name"_err_en_US,
-        *details.derivedType()->scope());
+        *details.derivedType()->GetUltimate().scope());
   }
   generic.set(isFunction ? Symbol::Flag::Function : Symbol::Flag::Subroutine);
 }
 
 // SubprogramVisitor implementation
 
 // Return false if it is actually an assignment statement.
 bool SubprogramVisitor::HandleStmtFunction(const parser::StmtFunctionStmt &x) {
if (auto *existingGeneric{ultimate.detailsIf<GenericDetails>()}) {
         info.Resolve(existing);
         return;
       } else {
         // Host association of a generic is handled in ResolveGeneric()
         CHECK(existing->has<HostAssocDetails>());
       }
     } else if (ultimate.has<SubprogramDetails>() ||
         ultimate.has<SubprogramNameDetails>()) {
-      genericDetails.set_specific(ultimate);
+      genericDetails.set_specific(*existing);
     } else if (ultimate.has<DerivedTypeDetails>()) {
-      genericDetails.set_derivedType(ultimate);
+      genericDetails.set_derivedType(*existing);
     } else {
       SayAlreadyDeclared(symbolName, *existing);
       return;
     }
     EraseSymbol(*existing);
   }
   info.Resolve(&MakeSymbol(symbolName, Attrs{}, std::move(genericDetails)));
 }

flang/test/Semantics/modfile52.f90

+! RUN: %python %S/test_modfile.py %s %flang_fc1
+! Ensure that procedure name or derived type name that has been shadowed
+! behind a generic interface gets its proper USE statement in a module file.
+module m1
+ contains
+  subroutine foo
+  end subroutine
+end module
+module m2
+  use m1
+  interface foo
+    procedure foo
+  end interface
+end module
+module m3
+  type foo
+  end type
+end module
+module m4
+  use m4
+  interface foo
+    procedure bar
+  end interface
+ contains
+  integer function bar
+  end function
+end module
+
+!Expect: m1.mod
+!module m1
+!contains
+!subroutine foo()
+!end
+!end
+
+!Expect: m2.mod
+!module m2
+!use m1,only:foo
+!interface foo
+!procedure::foo
+!end interface
+!end
+
+!Expect: m3.mod
+!module m3
+!type::foo
+!end type
+!end
+
+!Expect: m4.mod
+!module m4
+!interface foo
+!procedure::bar
+!end interface
+!contains
+!function bar()
+!integer(4)::bar
+!end
+!end