[flang] Add tests for passing procedure arguments with implicit interfaces

[PeteSteinfeld]

Summary

It's possible to declare an external procedure with an implicit interface and
then pass it as an actual argument to a subprogram expecting a procedure
argument. I added tests for this and added an error message to distinguish
passing an actual argument with an implicit interface from passing an argument
with a mismatched explicit interface.

[klausler]

If a dummy procedure has an explicit interface, the actual procedure must conform to it (15.5.2.9 paragraph 1). Do your changes allow a actual procedure with an implicit interface to be associated with a dummy procedure with an explicit interface?

[PeteSteinfeld]

In D94505#2493131, @klausler wrote:

If a dummy procedure has an explicit interface, the actual procedure must conform to it (15.5.2.9 paragraph 1). Do your changes allow a actual procedure with an implicit interface to be associated with a dummy procedure with an explicit interface?

My changes allow a procedure declared as "external :: func" to be passed to a procedure dummy argument with an explicit interface. This construct is allowed by pgf90, GNU, IBM, Intel, and NAG. I've implemented this by checking "HasExplicitInterface()" on the characteristics of the actual argument.

I'm not sure how to think about all of this. Does the standard require that a compiler reject a program when the compiler cannot verify at compile time if the characteristics are the same? Are these other compilers not properly enforcing the standard?

I'll investigate other ways to declare procedures with implicit interfaces to see if my implementation is too broad.

[PeteSteinfeld]

I changed this update to just add some tests and a new error message.

[klausler]

flang/lib/Semantics/check-call.cpp

552

"which is not known to be compatible with" might be better.

[PeteSteinfeld]

flang/lib/Semantics/check-call.cpp

552

Good suggestion. I'll do it.

flang/lib/Semantics/check-call.cpp

if (auto argChars{characteristics::DummyArgument::FromActual(
               argInterface.attrs.reset(
                   characteristics::Procedure::Attr::NullPointer);
             }
           }
           if (!interface.IsPure()) {
             // 15.5.2.9(1): if dummy is not pure, actual need not be.
             argInterface.attrs.reset(characteristics::Procedure::Attr::Pure);
           }
-          if (interface.HasExplicitInterface()) {
+          if (interface.HasExplicitInterface() &&
+              argInterface.HasExplicitInterface()) {
             if (interface != argInterface) {
               messages.Say(
                   "Actual argument procedure has interface incompatible with %s"_err_en_US,
                   dummyName);
             }
           } else { // 15.5.2.9(2,3)
             if (interface.IsSubroutine() && argInterface.IsFunction()) {
               messages.Say(
                   "Actual argument associated with procedure %s is a function but must be a subroutine"_err_en_US,
                   dummyName);
             } else if (interface.IsFunction()) {
               if (argInterface.IsFunction()) {
                 if (interface.functionResult != argInterface.functionResult) {
                   messages.Say(
                       "Actual argument function associated with procedure %s has incompatible result type"_err_en_US,
                       dummyName);
                 }
               } else if (argInterface.IsSubroutine()) {
                 messages.Say(
                     "Actual argument associated with procedure %s is a subroutine but must be a function"_err_en_US,
                     dummyName);

flang/test/Semantics/call09.f90

contains
   end function
 
   subroutine s01(p)
     procedure(realfunc), pointer, intent(in) :: p
   end subroutine
   subroutine s02(p)
     procedure(realfunc), pointer :: p
   end subroutine
+  subroutine s03(p)
+    procedure(realfunc) :: p
+  end subroutine
 
   subroutine selemental1(p)
     procedure(cos) :: p ! ok
   end subroutine
 
   real elemental function elemfunc(x)
     real, intent(in) :: x
     elemfunc = x
function intprocptr()
     intprocptr => intfunc
   end function
 
   subroutine test1 ! 15.5.2.9(5)
     intrinsic :: sin
     procedure(realfunc), pointer :: p
     procedure(intfunc), pointer :: ip
     integer, pointer :: intPtr
+    external :: extfunc
+    external :: extfuncPtr
+    pointer :: extfuncPtr
     p => realfunc
     ip => intfunc
     call s01(realfunc) ! ok
     !ERROR: Actual argument procedure has interface incompatible with dummy argument 'p='
     call s01(intfunc)
     call s01(p) ! ok
     call s01(procptr()) ! ok
     !ERROR: Actual argument procedure has interface incompatible with dummy argument 'p='
     call s01(intprocptr())
     call s01(null()) ! ok
     call s01(null(p)) ! ok
     !ERROR: Actual argument procedure has interface incompatible with dummy argument 'p='
     call s01(null(ip))
     call s01(sin) ! ok
     !ERROR: Actual argument associated with procedure dummy argument 'p=' is not a procedure
     call s01(null(intPtr))
     !ERROR: Actual argument associated with procedure dummy argument 'p=' is not a procedure
     call s01(B"0101")
+    call s01(extfunc) ! ok
     !ERROR: Actual argument associated with procedure pointer dummy argument 'p=' must be a POINTER unless INTENT(IN)
     call s02(realfunc)
     call s02(p) ! ok
     !ERROR: Actual argument procedure has interface incompatible with dummy argument 'p='
     call s02(ip)
     !ERROR: Actual argument associated with procedure pointer dummy argument 'p=' must be a POINTER unless INTENT(IN)
     call s02(procptr())
     !ERROR: Actual argument associated with procedure pointer dummy argument 'p=' must be a POINTER unless INTENT(IN)
     call s02(null())
     !ERROR: Actual argument associated with procedure pointer dummy argument 'p=' must be a POINTER unless INTENT(IN)
     call s02(null(p))
     !ERROR: Actual argument associated with procedure pointer dummy argument 'p=' must be a POINTER unless INTENT(IN)
     call s02(sin)
+    !ERROR: Actual argument associated with procedure pointer dummy argument 'p=' must be a POINTER unless INTENT(IN)
+    call s02(extfunc) ! ok
+    call s03(extfuncPtr) ! ok
   end subroutine
 
   subroutine callsub(s)
     call s
   end subroutine
   subroutine takesrealfunc1(f)
     external f
     real f