[flang] Avoid crash in error recovery

[klausler]

Summary

When a PASS() clause names a nonexistent dummy argument, don't crash
later in expression semantics.
Fixes https://github.com/llvm/llvm-project/issues/63487.

[PeteSteinfeld]

The new test that you added doesn't trigger the crash in the original test.

[klausler]

Fix new test.

[PeteSteinfeld]

It looks like something went wrong in your update. These latest changes don't seem related to the description of the patch.

[klausler]

Update with the right patch.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Semantics/expression.cpp

return common::visit(
           return details.passName();
         } else {
           return std::optional<parser::CharBlock>{};
         }
       },
       proc.details());
 }
 
-static int GetPassIndex(const Symbol &proc) {
+static std::optional<int> GetPassIndex(const Symbol &proc) {
   CHECK(!proc.attrs().test(semantics::Attr::NOPASS));
   std::optional<parser::CharBlock> passName{GetPassName(proc)};
   const auto *interface {
     semantics::FindInterface(proc)
   };
   if (!passName || !interface) {
     return 0; // first argument is passed-object
   }
   const auto &subp{interface->get<semantics::SubprogramDetails>()};
   int index{0};
   for (const auto *arg : subp.dummyArgs()) {
     if (arg && arg->name() == passName) {
       return index;
     }
     ++index;
   }
-  DIE("PASS argument name not in dummy argument list");
+  return std::nullopt;
 }
 
 // Injects an expression into an actual argument list as the "passed object"
 // for a type-bound procedure reference that is not NOPASS.  Adds an
 // argument keyword if possible, but not when the passed object goes
 // before a positional argument.
 // e.g., obj%tbp(x) -> tbp(obj,x).
 static void AddPassArg(ActualArguments &actuals, const Expr<SomeDerived> &expr,
     const Symbol &component, bool isPassedObject = true) {
   if (component.attrs().test(semantics::Attr::NOPASS)) {
     return;
   }
-  int passIndex{GetPassIndex(component)};
+  std::optional<int> passIndex{GetPassIndex(component)};
+  if (!passIndex) {
+    return; // error recovery
+  }
   auto iter{actuals.begin()};
   int at{0};
-  while (iter < actuals.end() && at < passIndex) {
+  while (iter < actuals.end() && at < *passIndex) {
     if (*iter && (*iter)->keyword()) {
       iter = actuals.end();
       break;
     }
     ++iter;
     ++at;
   }
   ActualArgument passed{AsGenericExpr(common::Clone(expr))};
if (scope) {
     // instantiations don't have redundant copies of bindings or
     // generics.
     scope = DEREF(scope->derivedTypeSpec()).typeSymbol().scope();
   }
   generic = scope ? scope->FindComponent(oprName) : nullptr;
   if (generic) {
     ExpressionAnalyzer::AdjustActuals adjustment{
         [&](const Symbol &proc, ActualArguments &) {
-          return passIndex == GetPassIndex(proc);
+          return passIndex == GetPassIndex(proc).value_or(-1);
         }};
     auto pair{
         context_.ResolveGeneric(*generic, actuals_, adjustment, isSubroutine)};
     if (const Symbol *binding{pair.first}) {
       CHECK(binding->has<semantics::ProcBindingDetails>());
       // Use the most recent override of the binding, if any
       return scope->FindComponent(binding->name());
     } else {

flang/test/Semantics/resolve52.f90

module m3
   contains
     !ERROR: 'z' is not a dummy argument of procedure interface 's'
     procedure, pass(z) :: p => s
   end type
 contains
   subroutine s(x)
     class(t) :: x
   end
+  subroutine test
+    type(t) x
+    !ERROR: Dummy argument 'x=' (#1) is not OPTIONAL and is not associated with an actual argument in this procedure reference
+    call x%p
+  end
 end
 
 module m4
   type :: t
     !ERROR: Passed-object dummy argument 'x' of procedure 'a' may not have the POINTER attribute
     procedure(s1), pointer :: a
     !ERROR: Passed-object dummy argument 'x' of procedure 'b' may not have the ALLOCATABLE attribute
     procedure(s2), pointer, pass(x) :: b