[flang] Fix crash from a blank BIND(C,NAME="") on subprogram

[klausler]

Summary

A recent change fixed the processing of BIND(C,NAME=expr) character
expressions so that they are evaluated as constants in the scope of
the subprogram. However, when the character name expression results
in an empty value after trimming, the compiler emits a warning message,
and this message is now causing a crash due to a lack of statement
context. To fix, extend the deferred processing of the BIND(C,NAME="")
so that a basic statement context exists.

flang/lib/Semantics/resolve-names.cpp

       const ProgramTree::EntryStmtList * = nullptr);
   bool BeginMpSubprogram(const parser::Name &);
   void PushBlockDataScope(const parser::Name &);
-  void EndSubprogram(
+  void EndSubprogram(std::optional<parser::CharBlock> stmtSource = std::nullopt,
       const std::optional<parser::LanguageBindingSpec> * = nullptr);
 
 protected:

   return BeginSubprogram(name, Symbol::Flag::Subroutine);
 }
 void SubprogramVisitor::Post(const parser::InterfaceBody::Subroutine &x) {
-  EndSubprogram(&std::get<std::optional<parser::LanguageBindingSpec>>(
-      std::get<parser::Statement<parser::SubroutineStmt>>(x.t).statement.t));
+  const auto &stmt{std::get<parser::Statement<parser::SubroutineStmt>>(x.t)};
+  EndSubprogram(stmt.source,
+      &std::get<std::optional<parser::LanguageBindingSpec>>(stmt.statement.t));
 }
 bool SubprogramVisitor::Pre(const parser::InterfaceBody::Function &x) {
   const auto &name{std::get<parser::Name>(

   return BeginSubprogram(name, Symbol::Flag::Function);
 }
 void SubprogramVisitor::Post(const parser::InterfaceBody::Function &x) {
-  const auto &maybeSuffix{std::get<std::optional<parser::Suffix>>(
-      std::get<parser::Statement<parser::FunctionStmt>>(x.t).statement.t)};
-  EndSubprogram(maybeSuffix ? &maybeSuffix->binding : nullptr);
+  const auto &stmt{std::get<parser::Statement<parser::FunctionStmt>>(x.t)};
+  const auto &maybeSuffix{
+      std::get<std::optional<parser::Suffix>>(stmt.statement.t)};
+  EndSubprogram(stmt.source, maybeSuffix ? &maybeSuffix->binding : nullptr);
 }
 
 bool SubprogramVisitor::Pre(const parser::SubroutineStmt &stmt) {

 }
 
 void SubprogramVisitor::EndSubprogram(
+    std::optional<parser::CharBlock> stmtSource,
     const std::optional<parser::LanguageBindingSpec> *binding) {
   if (binding && *binding && currScope().symbol()) {
     // Finally process the BIND(C,NAME=name) now that symbols in the name
     // expression will resolve local names.
     auto flagRestorer{common::ScopedSet(inSpecificationPart_, false)};
+    auto originalStmtSource{messageHandler().currStmtSource()};
+    messageHandler().set_currStmtSource(stmtSource);
     BeginAttrs();
     Walk(**binding);
     SetBindNameOn(*currScope().symbol());
     currScope().symbol()->attrs() |= EndAttrs();
+    messageHandler().set_currStmtSource(originalStmtSource);
   }
   PopScope();
 }

 }
 
 void ResolveNamesVisitor::EndScopeForNode(const ProgramTree &node) {
-  using BindingPtr = const std::optional<parser::LanguageBindingSpec> *;
-  EndSubprogram(common::visit(
+  std::optional<parser::CharBlock> stmtSource;
+  const std::optional<parser::LanguageBindingSpec> *binding{nullptr};
+  common::visit(
       common::visitors{
-          [](const parser::Statement<parser::FunctionStmt> *stmt) {
+          [&](const parser::Statement<parser::FunctionStmt> *stmt) {
             if (stmt) {
+              stmtSource = stmt->source;
               if (const auto &maybeSuffix{
                       std::get<std::optional<parser::Suffix>>(
                           stmt->statement.t)}) {
-                return &maybeSuffix->binding;
+                binding = &maybeSuffix->binding;
               }
             }
-            return BindingPtr{};
           },
-          [](const parser::Statement<parser::SubroutineStmt> *stmt) {
-            return stmt ? &std::get<std::optional<parser::LanguageBindingSpec>>(
-                              stmt->statement.t)
-                        : BindingPtr{};
+          [&](const parser::Statement<parser::SubroutineStmt> *stmt) {
+            if (stmt) {
+              stmtSource = stmt->source;
+              binding = &std::get<std::optional<parser::LanguageBindingSpec>>(
+                  stmt->statement.t);
+            }
           },
-          [](const auto *) { return BindingPtr{}; },
+          [](const auto *) {},
       },
-      node.stmt()));
+      node.stmt());
+  EndSubprogram(stmtSource, binding);
 }
 
 // Some analyses and checks, such as the processing of initializers of