[flang] Enforce specification function rules on callee, not call

[klausler]

Summary

A function can't be a specification function if it has a dummy procedure
argument, even if it's optional and unused. So don't check the reference
for actual procedure arguments, but rather the characteristics of the
function.

[PeteSteinfeld]

Looks great!

flang/lib/Evaluate/check-expression.cpp

 public:
   using Result = std::optional<std::string>;
   using Base = AnyTraverse<CheckSpecificationExprHelper, Result>;
   explicit CheckSpecificationExprHelper(
       const semantics::Scope &s, FoldingContext &context)
       : Base{*this}, scope_{s}, context_{context} {}
   using Base::operator();
 
-  Result operator()(const ProcedureDesignator &) const {
-    return "dummy procedure argument";
-  }
   Result operator()(const CoarrayRef &) const { return "coindexed reference"; }
 
   Result operator()(const semantics::Symbol &symbol) const {
     const auto &ultimate{symbol.GetUltimate()};
     if (const auto *assoc{
             ultimate.detailsIf<semantics::AssocEntityDetails>()}) {
       return (*this)(assoc->expr());
     } else if (semantics::IsNamedConstant(ultimate) ||
if (const auto *symbol{x.proc().GetSymbol()}) {
         return "reference to statement function '"s +
             ultimate.name().ToString() + "'";
       }
       if (scope_.IsDerivedType()) { // C750, C754
         return "reference to function '"s + ultimate.name().ToString() +
             "' not allowed for derived type components or type parameter"
             " values";
       }
+      if (auto procChars{
+              characteristics::Procedure::Characterize(x.proc(), context_)}) {
+        const auto iter{std::find_if(procChars->dummyArguments.begin(),
+            procChars->dummyArguments.end(),
+            [](const characteristics::DummyArgument &dummy) {
+              return std::holds_alternative<characteristics::DummyProcedure>(
+                  dummy.u);
+            })};
+        if (iter != procChars->dummyArguments.end()) {
+          return "reference to function '"s + ultimate.name().ToString() +
+              "' with dummy procedure argument '" + iter->name + '\'';
+        }
+      }
+      // References to internal functions are caught in expression semantics.
       // TODO: other checks for standard module procedures
     } else {
       const SpecificIntrinsic &intrin{DEREF(x.proc().GetSpecificIntrinsic())};
       if (scope_.IsDerivedType()) { // C750, C754
         if ((context_.intrinsics().IsIntrinsic(intrin.name) &&
                 badIntrinsicsForComponents_.find(intrin.name) !=
                     badIntrinsicsForComponents_.end()) ||
             IsProhibitedFunction(intrin.name)) {

flang/test/Semantics/expr-errors02.f90

interface
     integer function foo()
     end function
     pure real function realfunc(x)
       real, intent(in) :: x
     end function
     pure integer function hasProcArg(p)
       import realfunc
       procedure(realfunc) :: p
+      optional :: p
     end function
   end interface
   integer :: coarray[*]
  contains
   pure integer function modulefunc1(n)
     integer, value :: n
     modulefunc1 = n
   end function
   subroutine test(out, optional)
     !ERROR: Invalid specification expression: reference to impure function 'foo'
     type(t(foo())) :: x1
     integer :: local
     !ERROR: Invalid specification expression: reference to local entity 'local'
     type(t(local)) :: x2
     !ERROR: The internal function 'internal' may not be referenced in a specification expression
     type(t(internal(0))) :: x3
     integer, intent(out) :: out
     !ERROR: Invalid specification expression: reference to INTENT(OUT) dummy argument 'out'
     type(t(out)) :: x4
     integer, intent(in), optional :: optional
     !ERROR: Invalid specification expression: reference to OPTIONAL dummy argument 'optional'
     type(t(optional)) :: x5
-    !ERROR: Invalid specification expression: dummy procedure argument
-    type(t(hasProcArg(realfunc))) :: x6
+    !ERROR: Invalid specification expression: reference to function 'hasprocarg' with dummy procedure argument 'p'
+    type(t(hasProcArg())) :: x6
     !ERROR: Invalid specification expression: coindexed reference
     type(t(coarray[1])) :: x7
     type(t(kind(foo()))) :: x101 ! ok
     type(t(modulefunc1(0))) :: x102 ! ok
     type(t(modulefunc2(0))) :: x103 ! ok
    contains
     pure integer function internal(n)
       integer, value :: n
       internal = n
     end function
   end subroutine
   pure integer function modulefunc2(n)
     integer, value :: n
     modulefunc2 = n
   end function
 end module