[flang] Include missing internal interfaces in .mod files

[ekieri]

Summary

Interfaces which are internal to a procedure need to be included in
module files if (and only if) they are referenced in the interface of
the procedure. That is, they are needed if they are the interfaces of
dummy or return value procedures.

Fixes #53420

[ekieri]

Right, here is a first attempt at fixing [1]. Please check in that my intent, as described in the above summary, is the desired behaviour.

[1] https://github.com/llvm/llvm-project/issues/53420

[PeteSteinfeld]

I'm getting build errors because the variable subprogramDetails declared at line 1060 is never used.

[ekieri]

Sorry about that ...

[awarzynski]

@ekieri, many thanks for doing this! This is not my area of expertise, so I will defer to Pete.

I've just noticed that the pre-merge CI is failing to apply your patch. Perhaps try rebasing on top of main?

[ekieri]

Hi Andrzej, many thanks for all the encouragement! Yes, I added you more
like a cc (could rather have used that, I realise) as you did the
initial triage.

The CI log says git was unable to acquire a lock file, which did not
make me think it was a rebasing issue. But let's give it a try!

[awarzynski]

In D121738#3386677, @ekieri wrote:

Hi Andrzej, many thanks for all the encouragement! Yes, I added you more
like a cc (could rather have used that, I realise) as you did the
initial triage.

The CI log says git was unable to acquire a lock file, which did not
make me think it was a rebasing issue. But let's give it a try!

Ah! I checked manually - your patch applies cleanly and all tests pass :) Looks like an infra bug - reported here: https://github.com/google/llvm-premerge-checks/issues/395

-Andrzej

[PeteSteinfeld]

Thanks for doing this, Emil.

Aside from my small suggestion, everything builds and tests correctly and looks good.

flang/lib/Semantics/mod-file.cpp

1079–1081

This would be slightly more efficient as

needed = needed ||
  (details.isFunction() && hasInterface(&details.result()));

[ekieri]

Thanks for the suggestion, Pete!

flang/lib/Semantics/mod-file.cpp

if (const auto *useDetails{symbol.detailsIf<UseDetails>()}) {
         const Symbol *spec{generic->specific()};
         const Symbol *dt{generic->derivedType()};
         needed = needed || (spec && useSet_.count(*spec) > 0) ||
             (dt && useSet_.count(*dt) > 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};
+      const auto hasInterface{[&symbol](const Symbol *s) -> bool {
+        // Is 's' a procedure with interface 'symbol'?
+        if (s) {
+          if (const auto *sDetails{s->detailsIf<ProcEntityDetails>()}) {
+            const ProcInterface &sInterface{sDetails->interface()};
+            if (sInterface.symbol() == &symbol) {
+              return true;
+            }
+          }
+        }
+        return false;
+      }};
+      for (const Symbol *dummyArg : details.dummyArgs()) {
+        needed = needed || hasInterface(dummyArg);
+      }
+      needed =
+          needed || (details.isFunction() && hasInterface(&details.result()));
+      if (needed && needSet_.insert(symbol).second) {
+        need_.push_back(symbol);
+      }
     }
   }
 }
 
 void SubprogramSymbolCollector::DoSymbol(const Symbol &symbol) {
   DoSymbol(symbol.name(), symbol);
 }
 

flang/test/Semantics/modfile46.f90

+! RUN: %python %S/test_modfile.py %s %flang_fc1
+! Ensure that interfaces, which are internal to procedures and are used to
+! define the interface of dummy or return value procedures, are included in
+! .mod files.
+module m
+  implicit none
+contains
+  function f(x)
+    real, intent(in) :: x
+    abstract interface
+       subroutine used_int(x, p)
+         implicit none
+         real, intent(out) :: x
+         interface
+            subroutine inner_int(x)
+              implicit none
+              real, intent(out) :: x
+            end subroutine inner_int
+         end interface
+         procedure(inner_int) :: p
+       end subroutine used_int
+
+       pure logical function unused_int(i)
+         implicit none
+         integer, intent(in) :: i
+       end function unused_int
+    end interface
+    procedure(used_int), pointer :: f
+
+    f => null()
+  contains
+    subroutine internal()
+    end subroutine internal
+  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
+!end
+!end interface
+!end
+!end