[flang] Fix intrinsic/generic interaction regression

[klausler]

Summary

When resolving a procedure reference, do not allow a successful
intrinsic procedure probe result to override an existing
symbol.

[klausler]

Merge two patches together (both need to be present to fix problem without adding a test failure)

flang/lib/Evaluate/intrinsics.cpp

for (auto iter{subrRange.first}; iter != subrRange.second; ++iter) {
         return specificCall;
       }
     }
     if (IsIntrinsicFunction(call.name)) {
       context.messages().Say(
           "Cannot use intrinsic function '%s' as a subroutine"_err_en_US,
           call.name);
     }
-    return std::nullopt; // TODO
+    return std::nullopt;
   }
 
   // Helper to avoid emitting errors before it is sure there is no match
   parser::Messages localBuffer;
   parser::Messages *finalBuffer{context.messages().messages()};
   parser::ContextualMessages localMessages{
       context.messages().at(), finalBuffer ? &localBuffer : nullptr};
   FoldingContext localContext{context, localMessages};

flang/lib/Semantics/expression.cpp

if (isGenericInterface) {
     ExpressionAnalyzer::AdjustActuals noAdjustment;
     auto pair{ResolveGeneric(
         *symbol, arguments, noAdjustment, mightBeStructureConstructor)};
     resolution = pair.first;
     dueToNullActual = pair.second;
   }
   if (!resolution) {
     // Not generic, or no resolution; may be intrinsic
-    if (!symbol->attrs().test(semantics::Attr::EXTERNAL)) {
-      if (std::optional<SpecificCall> specificCall{context_.intrinsics().Probe(
-              CallCharacteristics{ultimate.name().ToString(), isSubroutine},
+    bool isIntrinsic{symbol->attrs().test(semantics::Attr::INTRINSIC)};
+    if (!isIntrinsic && !isGenericInterface) {
+      resolution = symbol;
+    } else if (std::optional<SpecificCall> specificCall{
+                   context_.intrinsics().Probe(
+                       CallCharacteristics{
+                           ultimate.name().ToString(), isSubroutine},
                        arguments, GetFoldingContext())}) {
-        CheckBadExplicitType(*specificCall, *symbol);
-        return CalleeAndArguments{
-            ProcedureDesignator{std::move(specificCall->specificIntrinsic)},
-            std::move(specificCall->arguments)};
-      } else if (symbol->attrs().test(semantics::Attr::INTRINSIC)) {
-        return std::nullopt;
-      }
-    }
+    } else {
       if (isGenericInterface) {
         EmitGenericResolutionError(*symbol, dueToNullActual);
+      }
       return std::nullopt;
-    } else {
-      // Neither a generic interface nor an intrinsic
-      resolution = symbol;
     }
   }
   if (resolution->GetUltimate().has<semantics::DerivedTypeDetails>()) {
     if (mightBeStructureConstructor) {
       return CalleeAndArguments{
           semantics::SymbolRef{*resolution}, std::move(arguments)};
     }
   } else if (IsProcedure(*resolution)) {