flang] Emit missing IMPORTs in module file interfaces

[klausler]

Summary

[When a symbol from the enclosing scope is necessary to declare
a procedure or procedure pointer dummy argument or function result
for a procedure interface, note it in the collection of symbols to
be imported when scanning that interface.

flang/lib/Semantics/mod-file.cpp

common::visit(common::visitors{
                         DoSymbol(*commonBlock);
                       }
                     },
                     [this](const CommonBlockDetails &details) {
                       for (const auto &object : details.objects()) {
                         DoSymbol(*object);
                       }
                     },
+                    [this](const ProcEntityDetails &details) {
+                      if (const Symbol * symbol{details.interface().symbol()}) {
+                        DoSymbol(*symbol);
+                      }
+                      DoType(details.interface().type());
+                    },
                     [](const auto &) {},
                 },
       symbol.details());
   if (!symbol.has<UseDetails>()) {
     DoType(symbol.GetType());
   }
   if (!scope.IsDerivedType()) {
     need_.push_back(symbol);
void SubprogramSymbolCollector::DoParamValue(const ParamValue &paramValue) {
   }
 }
 
 // Do we need a IMPORT of this symbol into an interface block?
 bool SubprogramSymbolCollector::NeedImport(
     const SourceName &name, const Symbol &symbol) {
   if (!isInterface_) {
     return false;
+  } else if (&symbol == scope_.symbol()) {
+    return false;
   } else if (symbol.owner().Contains(scope_)) {
     return true;
   } else if (const Symbol * found{scope_.FindSymbol(name)}) {
     // detect import from ancestor of use-associated symbol
     return found->has<UseDetails>() && found->owner() != scope_;
   } else {
     // "found" can be null in the case of a use-associated derived type's parent
     // type
     CHECK(symbol.has<DerivedTypeDetails>());
     return false;
   }
 }
 
 } // namespace Fortran::semantics

flang/test/Semantics/modfile46.f90

contains
   end function f
 end module m
 
 !Expect: m.mod
 !module m
 !contains
 !function f(x)
 !real(4),intent(in)::x
-!procedure(used_int),pointer::f
 !abstract interface
 !subroutine used_int(x,p)
 !real(4),intent(out)::x
-!procedure(inner_int)::p
 !interface
 !subroutine inner_int(x)
 !real(4),intent(out)::x
 !end
 !end interface
+!procedure(inner_int)::p
 !end
 !end interface
+!procedure(used_int),pointer::f
 !end
 !end

flang/test/Semantics/modfile49.f90

+! RUN: %python %S/test_modfile.py %s %flang_fc1
+! Ensure that symbols and types needed to declare procedures and procedure pointers
+! are properly imported into interfaces.
+module m
+  type :: t
+  end type
+  procedure(sin) :: ext
+  interface
+    subroutine subr(p1,p2)
+      import ext, t
+      procedure(ext) :: p1
+      procedure(type(t)), pointer :: p2
+    end subroutine
+    function fun() result(res)
+      import subr
+      procedure(subr), pointer :: res
+    end function
+  end interface
+end module
+
+!Expect: m.mod
+!module m
+!type::t
+!end type
+!intrinsic::sin
+!procedure(sin)::ext
+!interface
+!subroutine subr(p1,p2)
+!import::ext
+!import::t
+!procedure(ext)::p1
+!procedure(type(t)),pointer::p2
+!end
+!end interface
+!interface
+!function fun() result(res)
+!import::subr
+!procedure(subr),pointer::res
+!end
+!end interface
+!end