[flang] Allow implicit procedure pointers to associate with explicit procedures

[PeteSteinfeld]

Summary

Section 10.2.2.4, paragraph 3 states that, for procedure pointer assignment:

If the pointer object has an explicit interface, its characteristics shall be
the same as the pointer target ...

Thus, it's illegal for a procedure pointer with an explicit interface to be
associated with a procedure whose interface is implicit. However, there's no
prohibition that disallows a procedure pointer with an implicit interface from
being associated with a procedure whose interface is explicit.

We were incorrectly emitting an error message for this latter case.

We were also not covering the case of procedures with explicit
interfaces where calling them requires the use of a descriptor. Such
procedures cannot be associated with procedure pointers with implicit
interfaces.

[klausler]

We should not allow a procedure pointer with an implicit interface to be associated with a procedure that must be called only via on explicit interface, though. Use characteristics::Procedure::CanBeCalledViaImplicitInterface() to be sure.

[ekieri]

I agree with your interpretation of paragraph 3 (and Peter's of paragraph 4). However, both gfortran and nvfortran allow pointers with explicit interface to target procedures with implicit interface, if my test case is correct. Perhaps it could be useful to test with other compilers? And _if_ most of them take the more liberal standpoint on this, do we keep to the standard, or is it more user-friendly to implement an established extension? Or could the standard be read differently? No strong opinion from my side (but my instinct is to stay with the standard), just wanted to bring this to your attention.

[klausler]

Standard conformance notwithstanding, a procedure pointer should not be allowed to be associated with any target procedure (or pointer) that is not callable via the pointer after the association.

[PeteSteinfeld]

In D113706#3125573, @klausler wrote:

We should not allow a procedure pointer with an implicit interface to be associated with a procedure that must be called only via on explicit interface, though. Use characteristics::Procedure::CanBeCalledViaImplicitInterface() to be sure.

So we already know that the right hand side has an explicit interface. I'm having trouble constructing a test case where a procedure has an explicit interface and also can't be called via an implicit interface. @klausler, do you have an example?

[klausler]

In D113706#3125870, @PeteSteinfeld wrote:

In D113706#3125573, @klausler wrote:

We should not allow a procedure pointer with an implicit interface to be associated with a procedure that must be called only via on explicit interface, though. Use characteristics::Procedure::CanBeCalledViaImplicitInterface() to be sure.

So we already know that the right hand side has an explicit interface. I'm having trouble constructing a test case where a procedure has an explicit interface and also can't be called via an implicit interface. @klausler, do you have an example?

See 15.4.2.2 items (3)-(5). A good simple test case is a procedure with an assumed-shape dummy argument, or any other kind of dummy argument that requires the use of a descriptor. Calls to implicit interfaces never pass descriptors.

[PeteSteinfeld]

Responding to Peter's input regarding procedures with explicit interfaces that
cannot be called via procedure pointers with implicit interfaces.

[ekieri]

Thanks for your efforts! Looks good to me, but please wait for Peter. I left a few suggestions inline that you could consider.

flang/lib/Evaluate/tools.cpp

968

Nit: could be useful with a comment indicating that we have an "OK" path out of the function here, cf. ln 942.

It could also be useful if the error message mentioned which condition of 15.4.2.2 is violated. That would then apply to all checks through CanBeCalledViaImplicitInterface(), and I'd say it is better to land this patch first, and work on that as a follow-up (I could also help if you'd like). What do you think?

flang/test/Semantics/assign03.f90

174

Nit: As you mention in the summary, these are additional tests for 10.2.2.4(3).

[ekieri]

In D113706#3125805, @klausler wrote:

Standard conformance notwithstanding, a procedure pointer should not be allowed to be associated with any target procedure (or pointer) that is not callable via the pointer after the association.

I find it hard not to agree, thanks for clarifying!

[klausler]

flang/lib/Evaluate/tools.cpp

966

These lines can be joined.

[PeteSteinfeld]

flang/lib/Evaluate/tools.cpp

968

Thanks, @ekieri.

I added an "OK". I also added a "TODO" to enhance our reporting for why procedures cannot be called via implicit interfaces.

flang/test/Semantics/assign03.f90

174

Thanks.

I added a comment saying this.

flang/lib/Evaluate/characteristics.cpp

if (callee->functionResult) {
         return {*proc};
       }
     }
   }
   return std::nullopt;
 }
 
 bool Procedure::CanBeCalledViaImplicitInterface() const {
+  // TODO: Pass back information on why we return false
   if (attrs.test(Attr::Elemental) || attrs.test(Attr::BindC)) {
     return false; // 15.4.2.2(5,6)
   } else if (IsFunction() &&
       !functionResult->CanBeReturnedViaImplicitInterface()) {
     return false;
   } else {
     for (const DummyArgument &arg : dummyArguments) {
       if (!arg.CanBePassedViaImplicitInterface()) {

flang/lib/Evaluate/tools.cpp

std::optional<parser::MessageFixedText> CheckProcCompatibility(bool isCall,
   } else if (lhsProcedure->IsFunction() && !rhsProcedure->IsFunction()) {
     msg = "Function %s may not be associated with subroutine"
           " designator '%s'"_err_en_US;
   } else if (!lhsProcedure->IsFunction() && rhsProcedure->IsFunction()) {
     msg = "Subroutine %s may not be associated with function"
           " designator '%s'"_err_en_US;
   } else if (lhsProcedure->HasExplicitInterface() &&
       !rhsProcedure->HasExplicitInterface()) {
+    // Section 10.2.2.4, paragraph 3 prohibits associating a procedure pointer
+    // with an explicit interface with a procedure with an implicit interface
     msg = "Procedure %s with explicit interface may not be associated with"
           " procedure designator '%s' with implicit interface"_err_en_US;
   } else if (!lhsProcedure->HasExplicitInterface() &&
       rhsProcedure->HasExplicitInterface()) {
-    msg = "Procedure %s with implicit interface may not be associated with"
-          " procedure designator '%s' with explicit interface"_err_en_US;
+    if (!rhsProcedure->CanBeCalledViaImplicitInterface()) {
+      msg = "Procedure %s with implicit interface may not be associated "
+            "with procedure designator '%s' with explicit interface that "
+            "cannot be called via an implicit interface"_err_en_US;
+    }
   } else {
     msg = "Procedure %s associated with incompatible procedure"
           " designator '%s'"_err_en_US;
   }
   return msg;
 }
 
 // GetLastPointerSymbol()
 static const Symbol *GetLastPointerSymbol(const Symbol &symbol) {

flang/test/Semantics/assign03.f90

pure subroutine s_pure2(n)
       n = 1
     end subroutine s_pure2
     elemental subroutine s_elemental2(m,n)
       integer, intent(inout) :: m, n
       n = m + n
     end subroutine s_elemental2
   end
 
   ! 10.2.2.4(4)
   subroutine s6
     procedure(s), pointer :: p, q
     procedure(), pointer :: r
     external :: s_external
     !ERROR: Procedure pointer 'p' with explicit interface may not be associated with procedure designator 's_external' with implicit interface
     p => s_external
-    !ERROR: Procedure pointer 'r' with implicit interface may not be associated with procedure designator 's_module' with explicit interface
-    r => s_module
+    r => s_module ! OK for a pointer with implicit interface to be associated with a procedure with an explicit interface.  See 10.2.2.4 (3)
   end
 
   ! 10.2.2.4(5)
   subroutine s7
     procedure(real) :: f_external
     external :: s_external
     procedure(), pointer :: p_s
     procedure(real), pointer :: p_f

flang/test/Semantics/associated.f90

elemental integer function elementalFunc(n)
     integer, value :: n
     elementalFunc = n
   end function elementalFunc
 
   subroutine subr(i)
     integer :: i
   end subroutine subr
 
+  subroutine subrCannotBeCalledfromImplicit(i)
+    integer :: i(:)
+  end subroutine subrCannotBeCalledfromImplicit
+
   subroutine test()
     integer :: intVar
     integer, target :: targetIntVar1
     integer(kind=2), target :: targetIntVar2
     real, target :: targetRealVar
     integer, pointer :: intPointerVar1
     integer, pointer :: intPointerVar2
     integer, allocatable :: intAllocVar
subroutine test()
     !ERROR: Subroutine pointer 'subprocpointer' may not be associated with function designator 'intproc'
     subProcPointer => intProc
     !ERROR: Subroutine pointer 'subprocpointer' may not be associated with function designator 'intproc'
     lvar = associated(subProcPointer, intProc)
     !ERROR: Function pointer 'intprocpointer1' may not be associated with subroutine designator 'subproc'
     intProcPointer1 => subProc
     !ERROR: Function pointer 'intprocpointer1' may not be associated with subroutine designator 'subproc'
     lvar = associated(intProcPointer1, subProc)
-    !ERROR: Procedure pointer 'implicitprocpointer' with implicit interface may not be associated with procedure designator 'subr' with explicit interface
-    implicitProcPointer => subr
-    !ERROR: Procedure pointer 'implicitprocpointer' with implicit interface may not be associated with procedure designator 'subr' with explicit interface
-    lvar = associated(implicitProcPointer, subr)
+    implicitProcPointer => subr ! OK for an implicit point to point to an explicit proc
+    lvar = associated(implicitProcPointer, subr) ! OK
+    !ERROR: Procedure pointer 'implicitprocpointer' with implicit interface may not be associated with procedure designator 'subrcannotbecalledfromimplicit' with explicit interface that cannot be called via an implicit interface
+    lvar = associated(implicitProcPointer, subrCannotBeCalledFromImplicit)
   end subroutine test
 end subroutine assoc