[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

         }
       },
       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 (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

 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;

   }
   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>());

flang/test/Semantics/resolve52.f90

   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