[flang] Better error recovery when using erroneous procedures and pointers as intrinsic actual arguments

[klausler]

Summary

Instead of crashing with an internal error when a procedure or
procedure pointer with a badly declared interface is presented to
an intrinsic procedure like ASSOCIATED, emit an error message
and continue with compilation.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Evaluate/intrinsics.cpp

if (const auto &arg{rearranged[j]}) {
                 [&kw](const characteristics::DummyArgument &prev) {
                   return prev.name == kw;
                 })};
             if (iter == dummyArgs.end()) {
               break;
             }
           }
         }
-        auto dc{characteristics::DummyArgument::FromActual(
-            std::move(kw), *expr, context)};
-        if (!dc) {
-          common::die("INTERNAL: could not characterize intrinsic function "
-                      "actual argument '%s'",
-              expr->AsFortran().c_str());
-          return std::nullopt;
-        }
+        if (auto dc{characteristics::DummyArgument::FromActual(
+                std::move(kw), *expr, context)}) {
           dummyArgs.emplace_back(std::move(*dc));
           if (d.typePattern.kindCode == KindCode::same && !sameDummyArg) {
             sameDummyArg = j;
           }
+        } else { // error recovery
+          messages.Say(
+              "Could not characterize intrinsic function actual argument '%s'"_err_en_US,
+              expr->AsFortran().c_str());
+          return std::nullopt;
+        }
       } else {
         CHECK(arg->GetAssumedTypeDummy());
         dummyArgs.emplace_back(std::string{d.keyword},
             characteristics::DummyDataObject{DynamicType::AssumedType()});
       }
     } else {
       // optional argument is absent
       CHECK(d.optionality != Optionality::required);

flang/test/Semantics/associated.f90

subroutine test(assumedRank)
     procedure(realFunc), pointer :: realprocPointer1
     procedure(pureFunc), pointer :: pureFuncPointer
     procedure(elementalFunc) :: elementalProc
     external :: externalProc
     procedure(subrInt) :: subProc
     procedure(subrInt), pointer :: subProcPointer
     procedure(), pointer :: implicitProcPointer
     procedure(subrCannotBeCalledfromImplicit), pointer :: cannotBeCalledfromImplicitPointer
+    !ERROR: 'neverdeclared' must be an abstract interface or a procedure with an explicit interface
+    procedure(neverDeclared), pointer :: badPointer
     logical :: lVar
     type(t1) :: t1x
     type(t1), target :: t1xtarget
     type(t2) :: t2x
     type(t2), target :: t2xtarget
     integer, target :: targetIntArr(2)
     integer, target :: targetIntCoarray[*]
     integer, pointer :: intPointerArr(:)
subroutine test(assumedRank)
     !ERROR: Procedure pointer 'cannotbecalledfromimplicitpointer' with explicit interface that cannot be called via an implicit interface cannot be associated with procedure designator with an implicit interface
     cannotBeCalledfromImplicitPointer => externalProc
     !WARNING: Procedure pointer 'cannotbecalledfromimplicitpointer' with explicit interface that cannot be called via an implicit interface cannot be associated with procedure designator with an implicit interface
     lvar = associated(cannotBeCalledfromImplicitPointer, externalProc)
     !ERROR: TARGET= argument 'targetintarr([INTEGER(8)::2_8,1_8])' may not have a vector subscript or coindexing
     lvar = associated(intPointerArr, targetIntArr([2,1]))
     !ERROR: TARGET= argument 'targetintcoarray[1_8]' may not have a vector subscript or coindexing
     lvar = associated(intPointerVar1, targetIntCoarray[1])
+    !ERROR: 'neverdeclared' is not a procedure
+    !ERROR: Could not characterize intrinsic function actual argument 'badpointer'
+    !ERROR: 'neverdeclared' is not a procedure
+    !ERROR: Could not characterize intrinsic function actual argument 'badpointer'
+    lvar = associated(badPointer)
   end subroutine test
 end subroutine assoc