[flang] Preserve errors from generic matching

[klausler]

Summary

When searching for a matching specific procedure for a set of actual
arguments in a type-bound generic interface for a defined operator,
don't discard any error messages that may have been produced for
the specific that was found. Tweak the code to preserve those
messages and add them to the context's messages, and add a test.

[clementval]

LGTM

flang/lib/Semantics/expression.cpp

if (chars->functionResult &&
         chars->functionResult->IsAssumedLengthCharacter() &&
         !specificIntrinsic && !procIsDummy) {
       Say(callSite,
           "Assumed-length character function must be defined with a length to be called"_err_en_US);
     }
     ok &= semantics::CheckArguments(*chars, arguments, context_,
         context_.FindScope(callSite), treatExternalAsImplicit,
         specificIntrinsic);
-    if (procSymbol && !IsPureProcedure(*procSymbol)) {
-      if (const semantics::Scope *
-          pure{semantics::FindPureProcedureContaining(
-              context_.FindScope(callSite))}) {
-        Say(callSite,
-            "Procedure '%s' referenced in pure subprogram '%s' must be pure too"_err_en_US,
-            procSymbol->name(), DEREF(pure->symbol()).name());
-      }
-    }
-  }
+  }
   if (ok && !treatExternalAsImplicit && procSymbol &&
       !(chars && chars->HasExplicitInterface())) {
     if (const Symbol *global{FindGlobal(*procSymbol)};
         global && global != procSymbol && IsProcedure(*global)) {
       // Check a known global definition behind a local interface
       if (auto globalChars{characteristics::Procedure::Characterize(
               *global, context_.foldingContext())}) {
         semantics::CheckArguments(*globalChars, arguments, context_,
MaybeExpr ArgumentAnalyzer::TryDefinedOp(
   }
   MaybeExpr result;
   bool anyPossibilities{false};
   std::optional<parser::MessageFormattedText> inaccessible;
   std::vector<const Symbol *> hit;
   std::string oprNameString{
       isUserOp ? std::string{opr} : "operator("s + opr + ')'};
   parser::CharBlock oprName{oprNameString};
+  parser::Messages hitBuffer;
   {
-    auto restorer{context_.GetContextualMessages().DiscardMessages()};
+    parser::Messages buffer;
+    auto restorer{context_.GetContextualMessages().SetMessages(buffer)};
     const auto &scope{context_.context().FindScope(source_)};
     if (Symbol *symbol{scope.FindSymbol(oprName)}) {
       anyPossibilities = true;
       parser::Name name{symbol->name(), symbol};
       result = context_.AnalyzeDefinedOp(name, GetActuals());
       if (result) {
         inaccessible = CheckAccessibleSymbol(scope, *symbol);
         if (inaccessible) {
           result.reset();
         } else {
           hit.push_back(symbol);
+          hitBuffer = std::move(buffer);
         }
       }
     }
     for (std::size_t passIndex{0}; passIndex < actuals_.size(); ++passIndex) {
+      buffer.clear();
       const Symbol *generic{nullptr};
       if (const Symbol *binding{
               FindBoundOp(oprName, passIndex, generic, false)}) {
         anyPossibilities = true;
         if (MaybeExpr thisResult{TryBoundOp(*binding, passIndex)}) {
           if (auto thisInaccessible{
                   CheckAccessibleSymbol(scope, DEREF(generic))}) {
             inaccessible = thisInaccessible;
           } else {
             result = std::move(thisResult);
             hit.push_back(binding);
+            hitBuffer = std::move(buffer);
           }
         }
       }
     }
   }
   if (result) {
     if (hit.size() > 1) {
       if (auto *msg{context_.Say(
               "%zd matching accessible generic interfaces for %s were found"_err_en_US,
               hit.size(), ToUpperCase(opr))}) {
         for (const Symbol *symbol : hit) {
           AttachDeclaration(*msg, *symbol);
         }
       }
     }
+    if (auto *msgs{context_.GetContextualMessages().messages()}) {
+      msgs->Annex(std::move(hitBuffer));
+    }
   } else if (inaccessible) {
     context_.Say(source_, std::move(*inaccessible));
   } else if (anyPossibilities) {
     SayNoMatch(ToUpperCase(oprNameString), false);
   } else if (actuals_.size() == 2 && !AreConformable()) {
     context_.Say(
         "Operands of %s are not conformable; have rank %d and rank %d"_err_en_US,
         ToUpperCase(opr), actuals_[0]->Rank(), actuals_[1]->Rank());
   } else if (CheckForNullPointer()) {
     context_.Say(error, ToUpperCase(opr), TypeAsFortran(0), TypeAsFortran(1));
   }
   return result;
 }
 
 MaybeExpr ArgumentAnalyzer::TryDefinedOp(
     std::vector<const char *> oprs, parser::MessageFixedText error) {
   if (oprs.size() == 1) {
     return TryDefinedOp(oprs[0], error);
   }
   MaybeExpr result;
   std::vector<const char *> hit;
+  parser::Messages hitBuffer;
   {
-    auto restorer{context_.GetContextualMessages().DiscardMessages()};
     for (std::size_t i{0}; i < oprs.size(); ++i) {
+      parser::Messages buffer;
+      auto restorer{context_.GetContextualMessages().SetMessages(buffer)};
       if (MaybeExpr thisResult{TryDefinedOp(oprs[i], error)}) {
         result = std::move(thisResult);
         hit.push_back(oprs[i]);
+        hitBuffer = std::move(buffer);
       }
     }
   }
   if (hit.empty()) { // for the error
     result = TryDefinedOp(oprs[0], error);
   } else if (hit.size() > 1) {
     context_.Say(
         "Matching accessible definitions were found with %zd variant spellings of the generic operator ('%s', '%s')"_err_en_US,
         hit.size(), ToUpperCase(hit[0]), ToUpperCase(hit[1]));
+  } else { // one hit; preserve errors
+    context_.context().messages().Annex(std::move(hitBuffer));
   }
   return result;
 }
 
 MaybeExpr ArgumentAnalyzer::TryBoundOp(const Symbol &symbol, int passIndex) {
   ActualArguments localActuals{actuals_};
   const Symbol *proc{GetBindingResolution(GetType(passIndex), symbol)};
   if (!proc) {

flang/test/Semantics/pure01.f90

+! RUN: %python %S/test_errors.py %s %flang_fc1
+! Ensure that an impure bound operator can't be called
+! from a pure context.
+module m
+  type t
+   contains
+    procedure :: binding => func
+    generic :: operator(.not.) => binding
+  end type
+ contains
+  impure integer function func(x)
+    class(t), intent(in) :: x
+    func = 0
+  end
+  pure integer function test
+    !ERROR: Procedure 'func' referenced in pure subprogram 'test' must be pure too
+    test = .not. t()
+  end
+end