[flang] Fix check for distinguishable operators/assignments

[tskeith]

Summary

Change how generic operators and assignments are checked for
distinguishable procedures. Because of how they are invoked, available
type-bound generics and normal generics all have to be considered
together. This is different from how generic names are checked.

Move common part of checking into DistinguishabilityHelper so that it
can be used in both cases after the appropriate procedures have been
added.

Cache result of Procedure::Characterize(Symbol) in a map in
CheckHelper so that we don't have to worry about passing the
characterized Procedures around or the cost of recomputing them.

Add MakeOpName() to construct names for defined operators and assignment
for using in error messages. This eliminates the need for different
messages in those cases.

When the procedures for a defined operator or assignment are undistinguishable,
include the type name in the error message, otherwise it may be ambiguous.

Add missing check that procedures for defined operators are functions
and that their dummy arguments are INTENT(IN) or VALUE.

[tskeith]

• Improve error message

[tskeith]

• Use resolve96 for new test name

[richard.barton.arm]

This commit missed adding a dependency from libFortranEvaluate and libFortranSemantics. Adding it back in introduces a circular dependency and so breaks shared library builds.

Here's the failure I see:

9789.701 [508/8/3577] Linking CXX shared library lib/libFortranEvaluate.so.12git
FAILED: : && /usr/local/bin/clang++ -fPIC -stdlib=libc++ -fPIC -fvisibility-inlines-hidden -Werror -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wstring-conversion -fdiagnostics-color -ffunction-sections -fdata-sections -Wno-deprecated-copy -Wno-string-conversion -Wno-unused-command-line-argument -Wstring-conversion           -Wcovered-switch-default -Wno-nested-anon-types -O3  -stdlib=libc++ -Wl,-z,defs -Wl,-z,nodelete   -Wl,-rpath-link,/home/flang_aarch64_ubuntu_clang/flang-aarch64-ubuntu-clang/build/./lib  -Wl,-O3 -Wl,--gc-sections -shared -Wl,-soname,libFortranEvaluate.so.12git -o lib/libFortranEvaluate.so.12git tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/call.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/characteristics.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/check-expression.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/common.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/complex.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/constant.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/expression.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/fold.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/fold-character.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/fold-complex.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/fold-designator.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/fold-integer.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/fold-logical.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/fold-real.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/formatting.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/host.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/initial-image.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/integer.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/intrinsics.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/intrinsics-library.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/logical.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/real.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/shape.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/static-data.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/tools.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/type.cpp.o tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/variable.cpp.o  -Wl,-rpath,"\$ORIGIN/../lib"  lib/libFortranDecimal.so.12git  lib/libFortranParser.so.12git  lib/libFortranCommon.so.12git  lib/libLLVMSupport.so.12git  -Wl,-rpath-link,/home/flang_aarch64_ubuntu_clang/flang-aarch64-ubuntu-clang/build/lib && :
tools/flang/lib/Evaluate/CMakeFiles/obj.FortranEvaluate.dir/tools.cpp.o: In function `Fortran::evaluate::AttachDeclaration(Fortran::parser::Message&, Fortran::semantics::Symbol const&)':
tools.cpp:(.text._ZN7Fortran8evaluate17AttachDeclarationERNS_6parser7MessageERKNS_9semantics6SymbolE+0xa0): undefined reference to `Fortran::semantics::Scope::GetName() const'
clang-10: error: linker command failed with exit code 1 (use -v to see invocation)

You can see the error on the shared library buildbot (still in the staging instance): http://lab.llvm.org:8014/builders/flang-aarch64-ubuntu-clang/builds/866/steps/build-unified-tree/logs/stdio.

If make libFortranEvaluate depend on libFortranSemantics in CMake, I get this more explicit error:

CMake Error: The inter-target dependency graph contains the following strongly connected component (cycle):
  "FortranEvaluate" of type SHARED_LIBRARY
    depends on "FortranSemantics" (weak)
  "FortranSemantics" of type SHARED_LIBRARY
    depends on "FortranEvaluate" (weak)
At least one of these targets is not a STATIC_LIBRARY.  Cyclic dependencies are allowed only among static libraries.
CMake Generate step failed.  Build files cannot be regenerated correctly.

[richard.barton.arm]

I've posted what I think is the fix over on https://reviews.llvm.org/D87505

flang/include/flang/Semantics/tools.h

bool IsIntrinsicNumeric(
     const evaluate::DynamicType &, int, const evaluate::DynamicType &, int);
 bool IsIntrinsicLogical(const evaluate::DynamicType &);
 bool IsIntrinsicLogical(
     const evaluate::DynamicType &, int, const evaluate::DynamicType &, int);
 bool IsIntrinsicConcat(
     const evaluate::DynamicType &, int, const evaluate::DynamicType &, int);
 
 bool IsGenericDefinedOp(const Symbol &);
+bool IsDefinedOperator(SourceName);
+std::string MakeOpName(SourceName);
 bool DoesScopeContain(const Scope *maybeAncestor, const Scope &maybeDescendent);
 bool DoesScopeContain(const Scope *, const Symbol &);
 bool IsUseAssociated(const Symbol &, const Scope &);
 bool IsHostAssociated(const Symbol &, const Scope &);
 inline bool IsStmtFunction(const Symbol &symbol) {
   const auto *subprogram{symbol.detailsIf<SubprogramDetails>()};
   return subprogram && subprogram->stmtFunction();
 }

flang/lib/Evaluate/tools.cpp

parser::Message *AttachDeclaration(
   while (
       const auto *assoc{unhosted->detailsIf<semantics::HostAssocDetails>()}) {
     unhosted = &assoc->symbol();
   }
   if (const auto *binding{
           unhosted->detailsIf<semantics::ProcBindingDetails>()}) {
     if (binding->symbol().name() != symbol.name()) {
       message.Attach(binding->symbol().name(),
-          "Procedure '%s' is bound to '%s'"_en_US, symbol.name(),
-          binding->symbol().name());
+          "Procedure '%s' of type '%s' is bound to '%s'"_en_US, symbol.name(),
+          symbol.owner().GetName().value(), binding->symbol().name());
       return &message;
     }
     unhosted = &binding->symbol();
   }
   if (const auto *use{symbol.detailsIf<semantics::UseDetails>()}) {
     message.Attach(use->location(),
         "'%s' is USE-associated with '%s' in module '%s'"_en_US, symbol.name(),
         unhosted->name(), GetUsedModule(*use).name());

flang/lib/Semantics/check-declarations.cpp

 #include "flang/Semantics/semantics.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
 #include "flang/Semantics/type.h"
 #include <algorithm>
 
 namespace Fortran::semantics {
 
-using evaluate::characteristics::DummyArgument;
-using evaluate::characteristics::DummyDataObject;
-using evaluate::characteristics::DummyProcedure;
-using evaluate::characteristics::FunctionResult;
-using evaluate::characteristics::Procedure;
+namespace characteristics = evaluate::characteristics;
+using characteristics::DummyArgument;
+using characteristics::DummyDataObject;
+using characteristics::DummyProcedure;
+using characteristics::FunctionResult;
+using characteristics::Procedure;
 
 class CheckHelper {
 public:
   explicit CheckHelper(SemanticsContext &c) : context_{c} {}
   CheckHelper(SemanticsContext &c, const Scope &s) : context_{c}, scope_{&s} {}
 
+  SemanticsContext &context() { return context_; }
   void Check() { Check(context_.globalScope()); }
   void Check(const ParamValue &, bool canBeAssumed);
   void Check(const Bound &bound) { CheckSpecExpr(bound.GetExplicit()); }
   void Check(const ShapeSpec &spec) {
     Check(spec.lbound());
     Check(spec.ubound());
   }
   void Check(const ArraySpec &);
   void Check(const DeclTypeSpec &, bool canHaveAssumedTypeParameters);
   void Check(const Symbol &);
   void Check(const Scope &);
   void CheckInitialization(const Symbol &);
+  const Procedure *Characterize(const Symbol &);
 
 private:
   template <typename A> void CheckSpecExpr(const A &x) {
     evaluate::CheckSpecificationExpr(
         x, messages_, DEREF(scope_), context_.intrinsics());
   }
   void CheckValue(const Symbol &, const DerivedTypeSpec *);
   void CheckVolatile(
       const Symbol &, bool isAssociated, const DerivedTypeSpec *);
   void CheckPointer(const Symbol &);
   void CheckPassArg(
       const Symbol &proc, const Symbol *interface, const WithPassArg &);
   void CheckProcBinding(const Symbol &, const ProcBindingDetails &);
   void CheckObjectEntity(const Symbol &, const ObjectEntityDetails &);
   void CheckArraySpec(const Symbol &, const ArraySpec &);
   void CheckProcEntity(const Symbol &, const ProcEntityDetails &);
   void CheckSubprogram(const Symbol &, const SubprogramDetails &);
   void CheckAssumedTypeEntity(const Symbol &, const ObjectEntityDetails &);
   void CheckDerivedType(const Symbol &, const DerivedTypeDetails &);
-  void CheckHostAssoc(const Symbol &, const HostAssocDetails &);
   void CheckGeneric(const Symbol &, const GenericDetails &);
-  std::optional<std::vector<Procedure>> Characterize(const SymbolVector &);
-  bool CheckDefinedOperator(const SourceName &, const GenericKind &,
-      const Symbol &, const Procedure &);
+  void CheckHostAssoc(const Symbol &, const HostAssocDetails &);
+  bool CheckDefinedOperator(
+      SourceName, GenericKind, const Symbol &, const Procedure &);
   std::optional<parser::MessageFixedText> CheckNumberOfArgs(
       const GenericKind &, std::size_t);
   bool CheckDefinedOperatorArg(
       const SourceName &, const Symbol &, const Procedure &, std::size_t);
   bool CheckDefinedAssignment(const Symbol &, const Procedure &);
   bool CheckDefinedAssignmentArg(const Symbol &, const DummyArgument &, int);
-  void CheckSpecificsAreDistinguishable(
-      const Symbol &, const GenericDetails &, const std::vector<Procedure> &);
+  void CheckSpecificsAreDistinguishable(const Symbol &, const GenericDetails &);
   void CheckEquivalenceSet(const EquivalenceSet &);
   void CheckBlockData(const Scope &);
-
-  void SayNotDistinguishable(
-      const SourceName &, GenericKind, const Symbol &, const Symbol &);
+  void CheckGenericOps(const Scope &);
   bool CheckConflicting(const Symbol &, Attr, Attr);
   bool InPure() const {
     return innermostSymbol_ && IsPureProcedure(*innermostSymbol_);
   }
   bool InFunction() const {
     return innermostSymbol_ && IsFunction(*innermostSymbol_);
   }
   template <typename... A>
private:
 
   SemanticsContext &context_;
   evaluate::FoldingContext &foldingContext_{context_.foldingContext()};
   parser::ContextualMessages &messages_{foldingContext_.messages()};
   const Scope *scope_{nullptr};
   // This symbol is the one attached to the innermost enclosing scope
   // that has a symbol.
   const Symbol *innermostSymbol_{nullptr};
+  // Cache of calls to Procedure::Characterize(Symbol)
+  std::map<SymbolRef, std::optional<Procedure>> characterizeCache_;
+};
+
+class DistinguishabilityHelper {
+public:
+  DistinguishabilityHelper(SemanticsContext &context) : context_{context} {}
+  void Add(const Symbol &, GenericKind, const Symbol &, const Procedure &);
+  void Check();
+
+private:
+  void SayNotDistinguishable(
+      const SourceName &, GenericKind, const Symbol &, const Symbol &);
+
+  SemanticsContext &context_;
+  struct ProcedureInfo {
+    GenericKind kind;
+    const Symbol &symbol;
+    const Procedure &procedure;
+  };
+  std::map<SourceName, std::vector<ProcedureInfo>> nameToInfo_;
 };
 
 void CheckHelper::Check(const ParamValue &value, bool canBeAssumed) {
   if (value.isAssumed()) {
     if (!canBeAssumed) { // C795, C721, C726
       messages_.Say(
           "An assumed (*) type parameter may be used only for a (non-statement"
           " function) dummy argument, associate name, named constant, or"

 
 // When a module subprogram has the MODULE prefix the following must match
 // with the corresponding separate module procedure interface body:
 // - C1549: characteristics and dummy argument names
 // - C1550: binding label
 // - C1551: NON_RECURSIVE prefix
 class SubprogramMatchHelper {
 public:
-  explicit SubprogramMatchHelper(SemanticsContext &context)
-      : context{context} {}
+  explicit SubprogramMatchHelper(CheckHelper &checkHelper)
+      : checkHelper{checkHelper} {}
 
   void Check(const Symbol &, const Symbol &);
 
 private:
+  SemanticsContext &context() { return checkHelper.context(); }
   void CheckDummyArg(const Symbol &, const Symbol &, const DummyArgument &,
       const DummyArgument &);
   void CheckDummyDataObject(const Symbol &, const Symbol &,
       const DummyDataObject &, const DummyDataObject &);
   void CheckDummyProcedure(const Symbol &, const Symbol &,
       const DummyProcedure &, const DummyProcedure &);
   bool CheckSameIntent(
       const Symbol &, const Symbol &, common::Intent, common::Intent);
   template <typename... A>
   void Say(
       const Symbol &, const Symbol &, parser::MessageFixedText &&, A &&...);
   template <typename ATTRS>
   bool CheckSameAttrs(const Symbol &, const Symbol &, ATTRS, ATTRS);
   bool ShapesAreCompatible(const DummyDataObject &, const DummyDataObject &);
   evaluate::Shape FoldShape(const evaluate::Shape &);
   std::string AsFortran(DummyDataObject::Attr attr) {
     return parser::ToUpperCaseLetters(DummyDataObject::EnumToString(attr));
   }
   std::string AsFortran(DummyProcedure::Attr attr) {
     return parser::ToUpperCaseLetters(DummyProcedure::EnumToString(attr));
   }
 
-  SemanticsContext &context;
+  CheckHelper &checkHelper;
 };
 
 // 15.6.2.6 para 3 - can the result of an ENTRY differ from its function?
 bool CheckHelper::IsResultOkToDiffer(const FunctionResult &result) {
   if (result.attrs.test(FunctionResult::Attr::Allocatable) ||
       result.attrs.test(FunctionResult::Attr::Pointer)) {
     return false;
   }
bool CheckHelper::IsResultOkToDiffer(const FunctionResult &result) {
   return kind == context_.GetDefaultKind(category) ||
       (category == TypeCategory::Real &&
           kind == context_.doublePrecisionKind());
 }
 
 void CheckHelper::CheckSubprogram(
     const Symbol &symbol, const SubprogramDetails &details) {
   if (const Symbol * iface{FindSeparateModuleSubprogramInterface(&symbol)}) {
-    SubprogramMatchHelper{context_}.Check(symbol, *iface);
+    SubprogramMatchHelper{*this}.Check(symbol, *iface);
   }
   if (const Scope * entryScope{details.entryScope()}) {
     // ENTRY 15.6.2.6, esp. C1571
     std::optional<parser::MessageFixedText> error;
     const Symbol *subprogram{entryScope->symbol()};
     const SubprogramDetails *subprogramDetails{nullptr};
     if (subprogram) {
       subprogramDetails = subprogram->detailsIf<SubprogramDetails>();
if (details.implicitOrSpecExprError) {
       messages_.Say(
           "No explicit type declared for '%s'"_err_en_US, symbol.name());
     }
   }
 }
 
 void CheckHelper::CheckGeneric(
     const Symbol &symbol, const GenericDetails &details) {
-  const SymbolVector &specifics{details.specificProcs()};
-  const auto &bindingNames{details.bindingNames()};
-  std::optional<std::vector<Procedure>> procs{Characterize(specifics)};
-  if (!procs) {
-    return;
-  }
-  bool ok{true};
-  if (details.kind().IsIntrinsicOperator()) {
-    for (std::size_t i{0}; i < specifics.size(); ++i) {
-      auto restorer{messages_.SetLocation(bindingNames[i])};
-      ok &= CheckDefinedOperator(
-          symbol.name(), details.kind(), specifics[i], (*procs)[i]);
-    }
-  }
-  if (details.kind().IsAssignment()) {
-    for (std::size_t i{0}; i < specifics.size(); ++i) {
-      auto restorer{messages_.SetLocation(bindingNames[i])};
-      ok &= CheckDefinedAssignment(specifics[i], (*procs)[i]);
-    }
-  }
-  if (ok) {
-    CheckSpecificsAreDistinguishable(symbol, details, *procs);
-  }
+  CheckSpecificsAreDistinguishable(symbol, details);
 }
 
 // Check that the specifics of this generic are distinguishable from each other
-void CheckHelper::CheckSpecificsAreDistinguishable(const Symbol &generic,
-    const GenericDetails &details, const std::vector<Procedure> &procs) {
+void CheckHelper::CheckSpecificsAreDistinguishable(
+    const Symbol &generic, const GenericDetails &details) {
+  GenericKind kind{details.kind()};
   const SymbolVector &specifics{details.specificProcs()};
   std::size_t count{specifics.size()};
-  if (count < 2) {
+  if (count < 2 || !kind.IsName()) {
     return;
   }
-  GenericKind kind{details.kind()};
-  auto distinguishable{kind.IsAssignment() || kind.IsOperator()
-          ? evaluate::characteristics::DistinguishableOpOrAssign
-          : evaluate::characteristics::Distinguishable};
-  for (std::size_t i1{0}; i1 < count - 1; ++i1) {
-    auto &proc1{procs[i1]};
-    for (std::size_t i2{i1 + 1}; i2 < count; ++i2) {
-      auto &proc2{procs[i2]};
-      if (!distinguishable(proc1, proc2)) {
-        SayNotDistinguishable(
-            generic.name(), kind, specifics[i1], specifics[i2]);
-      }
+  DistinguishabilityHelper helper{context_};
+  for (const Symbol &specific : specifics) {
+    if (const Procedure * procedure{Characterize(specific)}) {
+      helper.Add(generic, kind, specific, *procedure);
     }
   }
-}
-
-void CheckHelper::SayNotDistinguishable(const SourceName &name,
-    GenericKind kind, const Symbol &proc1, const Symbol &proc2) {
-  auto &&text{kind.IsDefinedOperator()
-          ? "Generic operator '%s' may not have specific procedures '%s'"
-            " and '%s' as their interfaces are not distinguishable"_err_en_US
-          : "Generic '%s' may not have specific procedures '%s'"
-            " and '%s' as their interfaces are not distinguishable"_err_en_US};
-  auto &msg{
-      context_.Say(name, std::move(text), name, proc1.name(), proc2.name())};
-  evaluate::AttachDeclaration(msg, proc1);
-  evaluate::AttachDeclaration(msg, proc2);
+  helper.Check();
 }
 
 static bool ConflictsWithIntrinsicAssignment(const Procedure &proc) {
   auto lhs{std::get<DummyDataObject>(proc.dummyArguments[0].u).type};
   auto rhs{std::get<DummyDataObject>(proc.dummyArguments[1].u).type};
   return Tristate::No ==
       IsDefinedAssignment(lhs.type(), lhs.Rank(), rhs.type(), rhs.Rank());
 }
 
 static bool ConflictsWithIntrinsicOperator(
     const GenericKind &kind, const Procedure &proc) {
+  if (!kind.IsIntrinsicOperator()) {
+    return false;
+  }
   auto arg0{std::get<DummyDataObject>(proc.dummyArguments[0].u).type};
   auto type0{arg0.type()};
   if (proc.dummyArguments.size() == 1) { // unary
     return std::visit(
         common::visitors{
             [&](common::NumericOperator) { return IsIntrinsicNumeric(type0); },
             [&](common::LogicalOperator) { return IsIntrinsicLogical(type0); },
             [](const auto &) -> bool { DIE("bad generic kind"); },
return std::visit(
             },
             [](const auto &) -> bool { DIE("bad generic kind"); },
         },
         kind.u);
   }
 }
 
 // Check if this procedure can be used for defined operators (see 15.4.3.4.2).
-bool CheckHelper::CheckDefinedOperator(const SourceName &opName,
-    const GenericKind &kind, const Symbol &specific, const Procedure &proc) {
+bool CheckHelper::CheckDefinedOperator(SourceName opName, GenericKind kind,
+    const Symbol &specific, const Procedure &proc) {
+  if (context_.HasError(specific)) {
+    return false;
+  }
   std::optional<parser::MessageFixedText> msg;
   if (specific.attrs().test(Attr::NOPASS)) { // C774
     msg = "%s procedure '%s' may not have NOPASS attribute"_err_en_US;
   } else if (!proc.functionResult.has_value()) {
     msg = "%s procedure '%s' must be a function"_err_en_US;
   } else if (proc.functionResult->IsAssumedLengthCharacter()) {
     msg = "%s function '%s' may not have assumed-length CHARACTER(*)"
           " result"_err_en_US;
   } else if (auto m{CheckNumberOfArgs(kind, proc.dummyArguments.size())}) {
     msg = std::move(m);
   } else if (!CheckDefinedOperatorArg(opName, specific, proc, 0) |
       !CheckDefinedOperatorArg(opName, specific, proc, 1)) {
     return false; // error was reported
   } else if (ConflictsWithIntrinsicOperator(kind, proc)) {
     msg = "%s function '%s' conflicts with intrinsic operator"_err_en_US;
   } else {
     return true; // OK
   }
-  SayWithDeclaration(specific, std::move(msg.value()),
-      parser::ToUpperCaseLetters(opName.ToString()), specific.name());
+  SayWithDeclaration(
+      specific, std::move(*msg), MakeOpName(opName), specific.name());
+  context_.SetError(specific);
   return false;
 }
 
 // If the number of arguments is wrong for this intrinsic operator, return
 // false and return the error message in msg.
 std::optional<parser::MessageFixedText> CheckHelper::CheckNumberOfArgs(
     const GenericKind &kind, std::size_t nargs) {
+  if (!kind.IsIntrinsicOperator()) {
+    return std::nullopt;
+  }
   std::size_t min{2}, max{2}; // allowed number of args; default is binary
   std::visit(common::visitors{
                  [&](const common::NumericOperator &x) {
                    if (x == common::NumericOperator::Add ||
                        x == common::NumericOperator::Subtract) {
                      min = 1; // + and - are unary or binary
                    }
                  },
if (msg) {
     return false;
   }
   return true;
 }
 
 // Check if this procedure can be used for defined assignment (see 15.4.3.4.3).
 bool CheckHelper::CheckDefinedAssignment(
     const Symbol &specific, const Procedure &proc) {
+  if (context_.HasError(specific)) {
+    return false;
+  }
   std::optional<parser::MessageFixedText> msg;
   if (specific.attrs().test(Attr::NOPASS)) { // C774
     msg = "Defined assignment procedure '%s' may not have"
           " NOPASS attribute"_err_en_US;
   } else if (!proc.IsSubroutine()) {
     msg = "Defined assignment procedure '%s' must be a subroutine"_err_en_US;
   } else if (proc.dummyArguments.size() != 2) {
     msg = "Defined assignment subroutine '%s' must have"
           " two dummy arguments"_err_en_US;
   } else if (!CheckDefinedAssignmentArg(specific, proc.dummyArguments[0], 0) |
       !CheckDefinedAssignmentArg(specific, proc.dummyArguments[1], 1)) {
     return false; // error was reported
   } else if (ConflictsWithIntrinsicAssignment(proc)) {
     msg = "Defined assignment subroutine '%s' conflicts with"
           " intrinsic assignment"_err_en_US;
   } else {
     return true; // OK
   }
   SayWithDeclaration(specific, std::move(msg.value()), specific.name());
+  context_.SetError(specific);
   return false;
 }
 
 bool CheckHelper::CheckDefinedAssignmentArg(
     const Symbol &symbol, const DummyArgument &arg, int pos) {
   std::optional<parser::MessageFixedText> msg;
   if (arg.IsOptional()) {
     msg = "In defined assignment subroutine '%s', dummy argument '%s'"
if (pos == 0) {
       DIE("pos must be 0 or 1");
     }
   } else {
     msg = "In defined assignment subroutine '%s', dummy argument '%s'"
           " must be a data object"_err_en_US;
   }
   if (msg) {
     SayWithDeclaration(symbol, std::move(*msg), symbol.name(), arg.name);
+    context_.SetError(symbol);
     return false;
   }
   return true;
 }
 
 // Report a conflicting attribute error if symbol has both of these attributes
 bool CheckHelper::CheckConflicting(const Symbol &symbol, Attr a1, Attr a2) {
   if (symbol.attrs().test(a1) && symbol.attrs().test(a2)) {
     messages_.Say("'%s' may not have both the %s and %s attributes"_err_en_US,
         symbol.name(), EnumToString(a1), EnumToString(a2));
     return true;
   } else {
     return false;
   }
 }
 
-std::optional<std::vector<Procedure>> CheckHelper::Characterize(
-    const SymbolVector &specifics) {
-  std::vector<Procedure> result;
-  for (const Symbol &specific : specifics) {
-    auto proc{Procedure::Characterize(specific, context_.intrinsics())};
-    if (!proc || context_.HasError(specific)) {
-      return std::nullopt;
-    }
-    result.emplace_back(*proc);
-  }
-  return result;
+const Procedure *CheckHelper::Characterize(const Symbol &symbol) {
+  auto it{characterizeCache_.find(symbol)};
+  if (it == characterizeCache_.end()) {
+    auto pair{characterizeCache_.emplace(SymbolRef{symbol},
+        Procedure::Characterize(symbol, context_.intrinsics()))};
+    it = pair.first;
+  return common::GetPtrFromOptional(it->second);
 }
 
 void CheckHelper::CheckVolatile(const Symbol &symbol, bool isAssociated,
     const DerivedTypeSpec *derived) { // C866 - C868
   if (IsIntentIn(symbol)) {
     messages_.Say(
         "VOLATILE attribute may not apply to an INTENT(IN) argument"_err_en_US);
   }
if (const auto *overriddenBinding{
       }
       bool isNopass{symbol.attrs().test(Attr::NOPASS)};
       if (isNopass != overridden->attrs().test(Attr::NOPASS)) {
         SayWithDeclaration(*overridden,
             isNopass
                 ? "A NOPASS type-bound procedure may not override a passed-argument procedure"_err_en_US
                 : "A passed-argument type-bound procedure may not override a NOPASS procedure"_err_en_US);
       } else {
-        auto bindingChars{evaluate::characteristics::Procedure::Characterize(
-            binding.symbol(), context_.intrinsics())};
-        auto overriddenChars{evaluate::characteristics::Procedure::Characterize(
-            overriddenBinding->symbol(), context_.intrinsics())};
+        const auto *bindingChars{Characterize(binding.symbol())};
+        const auto *overriddenChars{Characterize(overriddenBinding->symbol())};
         if (bindingChars && overriddenChars) {
           if (isNopass) {
             if (!bindingChars->CanOverride(*overriddenChars, std::nullopt)) {
               SayWithDeclaration(*overridden,
                   "A type-bound procedure and its override must have compatible interfaces"_err_en_US);
             }
           } else {
             int passIndex{bindingChars->FindPassIndex(binding.passName())};
for (const auto &pair : scope) {
     Check(*pair.second);
   }
   for (const Scope &child : scope.children()) {
     Check(child);
   }
   if (scope.kind() == Scope::Kind::BlockData) {
     CheckBlockData(scope);
   }
+  CheckGenericOps(scope);
 }
 
 void CheckHelper::CheckEquivalenceSet(const EquivalenceSet &set) {
   auto iter{
       std::find_if(set.begin(), set.end(), [](const EquivalenceObject &object) {
         return FindCommonBlockContaining(object.symbol) != nullptr;
       })};
   if (iter != set.end()) {
if (!(symbol.has<CommonBlockDetails>() || symbol.has<UseDetails>() ||
                 !symbol.attrs().test(Attr::POINTER)))) {
       messages_.Say(symbol.name(),
           "'%s' may not appear in a BLOCK DATA subprogram"_err_en_US,
           symbol.name());
     }
   }
 }
 
+// Check distinguishability of generic assignment and operators.
+// For these, generics and generic bindings must be considered together.
+void CheckHelper::CheckGenericOps(const Scope &scope) {
+  DistinguishabilityHelper helper{context_};
+  auto addSpecifics{[&](const Symbol &generic) {
+    const auto *details{generic.GetUltimate().detailsIf<GenericDetails>()};
+    if (!details) {
+      return;
+    }
+    GenericKind kind{details->kind()};
+    if (!kind.IsAssignment() && !kind.IsOperator()) {
+      return;
+    }
+    const SymbolVector &specifics{details->specificProcs()};
+    const std::vector<SourceName> &bindingNames{details->bindingNames()};
+    for (std::size_t i{0}; i < specifics.size(); ++i) {
+      const Symbol &specific{*specifics[i]};
+      if (const Procedure * proc{Characterize(specific)}) {
+        auto restorer{messages_.SetLocation(bindingNames[i])};
+        if (kind.IsAssignment()) {
+          if (!CheckDefinedAssignment(specific, *proc)) {
+            continue;
+          }
+        } else {
+          if (!CheckDefinedOperator(generic.name(), kind, specific, *proc)) {
+            continue;
+          }
+        }
+        helper.Add(generic, kind, specific, *proc);
+      }
+    }
+  }};
+  for (const auto &pair : scope) {
+    const Symbol &symbol{*pair.second};
+    addSpecifics(symbol);
+    const Symbol &ultimate{symbol.GetUltimate()};
+    if (ultimate.has<DerivedTypeDetails>()) {
+      if (const Scope * typeScope{ultimate.scope()}) {
+        for (const auto &pair2 : *typeScope) {
+          addSpecifics(*pair2.second);
+        }
+      }
+    }
+  }
+  helper.Check();
+}
+
 void SubprogramMatchHelper::Check(
     const Symbol &symbol1, const Symbol &symbol2) {
   const auto details1{symbol1.get<SubprogramDetails>()};
   const auto details2{symbol2.get<SubprogramDetails>()};
   if (details1.isFunction() != details2.isFunction()) {
     Say(symbol1, symbol2,
         details1.isFunction()
             ? "Module function '%s' was declared as a subroutine in the"
if (bindName1.has_value() != bindName2.has_value()) {
     std::string string2{bindName2->AsFortran()};
     if (string1 != string2) {
       Say(symbol1, symbol2,
           "Module subprogram '%s' has binding label %s but the corresponding"
           " interface body has %s"_err_en_US,
           string1, string2);
     }
   }
-  auto proc1{Procedure::Characterize(symbol1, context.intrinsics())};
-  auto proc2{Procedure::Characterize(symbol2, context.intrinsics())};
+  const Procedure *proc1{checkHelper.Characterize(symbol1)};
+  const Procedure *proc2{checkHelper.Characterize(symbol2)};
   if (!proc1 || !proc2) {
     return;
   }
   if (proc1->functionResult && proc2->functionResult &&
       *proc1->functionResult != *proc2->functionResult) {
     Say(symbol1, symbol2,
         "Return type of function '%s' does not match return type of"
         " the corresponding interface body"_err_en_US);
if (intent1 == intent2) {
     return false;
   }
 }
 
 // Report an error referring to first symbol with declaration of second symbol
 template <typename... A>
 void SubprogramMatchHelper::Say(const Symbol &symbol1, const Symbol &symbol2,
     parser::MessageFixedText &&text, A &&...args) {
-  auto &message{context.Say(symbol1.name(), std::move(text), symbol1.name(),
+  auto &message{context().Say(symbol1.name(), std::move(text), symbol1.name(),
       std::forward<A>(args)...)};
   evaluate::AttachDeclaration(message, symbol2);
 }
 
 template <typename ATTRS>
 bool SubprogramMatchHelper::CheckSameAttrs(
     const Symbol &symbol1, const Symbol &symbol2, ATTRS attrs1, ATTRS attrs2) {
   if (attrs1 == attrs2) {
if (!attrs1.test(attr)) {
           AsFortran(attr));
     }
   });
   return false;
 }
 
 bool SubprogramMatchHelper::ShapesAreCompatible(
     const DummyDataObject &obj1, const DummyDataObject &obj2) {
-  return evaluate::characteristics::ShapesAreCompatible(
+  return characteristics::ShapesAreCompatible(
       FoldShape(obj1.type.shape()), FoldShape(obj2.type.shape()));
 }
 
 evaluate::Shape SubprogramMatchHelper::FoldShape(const evaluate::Shape &shape) {
   evaluate::Shape result;
   for (const auto &extent : shape) {
     result.emplace_back(
-        evaluate::Fold(context.foldingContext(), common::Clone(extent)));
+        evaluate::Fold(context().foldingContext(), common::Clone(extent)));
   }
   return result;
 }
 
+void DistinguishabilityHelper::Add(const Symbol &generic, GenericKind kind,
+    const Symbol &specific, const Procedure &procedure) {
+  if (!context_.HasError(specific)) {
+    nameToInfo_[generic.name()].emplace_back(
+        ProcedureInfo{kind, specific, procedure});
+  }
+}
+
+void DistinguishabilityHelper::Check() {
+  for (const auto &[name, info] : nameToInfo_) {
+    auto count{info.size()};
+    for (std::size_t i1{0}; i1 < count - 1; ++i1) {
+      const auto &[kind1, symbol1, proc1] = info[i1];
+      for (std::size_t i2{i1 + 1}; i2 < count; ++i2) {
+        const auto &[kind2, symbol2, proc2] = info[i2];
+        auto distinguishable{kind1.IsName()
+                ? evaluate::characteristics::Distinguishable
+                : evaluate::characteristics::DistinguishableOpOrAssign};
+        if (!distinguishable(proc1, proc2)) {
+          SayNotDistinguishable(name, kind1, symbol1, symbol2);
+        }
+      }
+    }
+  }
+}
+
+void DistinguishabilityHelper::SayNotDistinguishable(const SourceName &name,
+    GenericKind kind, const Symbol &proc1, const Symbol &proc2) {
+  std::string name1{proc1.name().ToString()};
+  std::string name2{proc2.name().ToString()};
+  if (kind.IsOperator() || kind.IsAssignment()) {
+    // proc1 and proc2 may come from different scopes so qualify their names
+    if (proc1.owner().IsDerivedType()) {
+      name1 = proc1.owner().GetName()->ToString() + '%' + name1;
+    }
+    if (proc2.owner().IsDerivedType()) {
+      name2 = proc2.owner().GetName()->ToString() + '%' + name2;
+    }
+  }
+  auto &msg{context_.Say(name,
+      "Generic '%s' may not have specific procedures '%s' and '%s'"
+      " as their interfaces are not distinguishable"_err_en_US,
+      MakeOpName(name), name1, name2)};
+  evaluate::AttachDeclaration(msg, proc1);
+  evaluate::AttachDeclaration(msg, proc2);
+}
+
 void CheckDeclarations(SemanticsContext &context) {
   CheckHelper{context}.Check();
 }
 
 void CheckInstantiatedDerivedType(
     SemanticsContext &context, const DerivedTypeSpec &type) {
   if (const Scope * scope{type.scope()}) {
     CheckHelper checker{context};
     for (const auto &pair : *scope) {
       checker.CheckInitialization(*pair.second);
     }
   }
 }
 
 } // namespace Fortran::semantics

flang/lib/Semantics/resolve-names-utils.h

 // Record that a Name has been resolved to a Symbol
 Symbol &Resolve(const parser::Name &, Symbol &);
 Symbol *Resolve(const parser::Name &, Symbol *);
 
 // Create a copy of msg with a new isFatal value.
 parser::MessageFixedText WithIsFatal(
     const parser::MessageFixedText &msg, bool isFatal);
 
-// Is this the name of a defined operator, e.g. ".foo."
-bool IsDefinedOperator(const SourceName &);
 bool IsIntrinsicOperator(const SemanticsContext &, const SourceName &);
 bool IsLogicalConstant(const SemanticsContext &, const SourceName &);
 
 template <typename T>
 MaybeIntExpr EvaluateIntExpr(SemanticsContext &context, const T &expr) {
   if (MaybeExpr maybeExpr{
           Fold(context.foldingContext(), AnalyzeExpr(context, expr))}) {
     if (auto *intExpr{evaluate::UnwrapExpr<SomeIntExpr>(*maybeExpr)}) {

flang/lib/Semantics/resolve-names-utils.cpp

 }
 
 parser::MessageFixedText WithIsFatal(
     const parser::MessageFixedText &msg, bool isFatal) {
   return parser::MessageFixedText{
       msg.text().begin(), msg.text().size(), isFatal};
 }
 
-bool IsDefinedOperator(const SourceName &name) {
-  const char *begin{name.begin()};
-  const char *end{name.end()};
-  return begin != end && begin[0] == '.' && end[-1] == '.';
-}
-
 bool IsIntrinsicOperator(
     const SemanticsContext &context, const SourceName &name) {
   std::string str{name.ToString()};
   for (int i{0}; i != common::LogicalOperator_enumSize; ++i) {
     auto names{context.languageFeatures().GetNames(LogicalOperator{i})};
     if (std::find(names.begin(), names.end(), str) != names.end()) {
       return true;
     }

flang/lib/Semantics/resolve-names.cpp

 }
 
 ModuleVisitor::SymbolRename ModuleVisitor::AddUse(
     const SourceName &localName, const SourceName &useName, Symbol *useSymbol) {
   if (!useModuleScope_) {
     return {}; // error occurred finding module
   }
   if (!useSymbol) {
-    Say(useName,
-        IsDefinedOperator(useName)
-            ? "Operator '%s' not found in module '%s'"_err_en_US
-            : "'%s' not found in module '%s'"_err_en_US,
-        useName, useModuleScope_->GetName().value());
+    Say(useName, "'%s' not found in module '%s'"_err_en_US, MakeOpName(useName),
+        useModuleScope_->GetName().value());
     return {};
   }
   if (useSymbol->attrs().test(Attr::PRIVATE)) {
-    Say(useName,
-        IsDefinedOperator(useName)
-            ? "Operator '%s' is PRIVATE in '%s'"_err_en_US
-            : "'%s' is PRIVATE in '%s'"_err_en_US,
-        useName, useModuleScope_->GetName().value());
+    Say(useName, "'%s' is PRIVATE in '%s'"_err_en_US, MakeOpName(useName),
+        useModuleScope_->GetName().value());
     return {};
   }
   auto &localSymbol{MakeSymbol(localName)};
   AddUse(useName, localSymbol, *useSymbol);
   return {&localSymbol, useSymbol};
 }
 
 // symbol must be either a Use or a Generic formed by merging two uses.
if (kind == ProcedureKind::ModuleProcedure) {
         CHECK(sd);
         if (symbol->owner().kind() != Scope::Kind::Module ||
             sd->isInterface()) {
           Say(*name, "'%s' is not a module procedure"_err_en_US);
         }
       }
     }
     if (!namesSeen.insert(name->source).second) {
-      Say(*name,
-          details.kind().IsDefinedOperator()
-              ? "Procedure '%s' is already specified in generic operator '%s'"_err_en_US
-              : "Procedure '%s' is already specified in generic '%s'"_err_en_US,
-          name->source, generic.name());
+      Say(name->source,
+          "Procedure '%s' is already specified in generic '%s'"_err_en_US,
+          name->source, MakeOpName(generic.name()));
       continue;
     }
     details.AddSpecificProc(*symbol, name->source);
   }
   specificProcs_.erase(range.first, range.second);
 }
 
 // Check that the specific procedures are all functions or all subroutines.
Symbol &ModuleVisitor::SetAccess(
     const SourceName &name, Attr attr, Symbol *symbol) {
   if (!symbol) {
     symbol = &MakeSymbol(name);
   }
   Attrs &attrs{symbol->attrs()};
   if (attrs.HasAny({Attr::PUBLIC, Attr::PRIVATE})) {
     // PUBLIC/PRIVATE already set: make it a fatal error if it changed
     Attr prev = attrs.test(Attr::PUBLIC) ? Attr::PUBLIC : Attr::PRIVATE;
-    auto msg{IsDefinedOperator(name)
-            ? "The accessibility of operator '%s' has already been specified as %s"_en_US
-            : "The accessibility of '%s' has already been specified as %s"_en_US};
-    Say(name, WithIsFatal(msg, attr != prev), name, EnumToString(prev));
+    Say(name,
+        WithIsFatal(
+            "The accessibility of '%s' has already been specified as %s"_en_US,
+            attr != prev),
+        MakeOpName(name), EnumToString(prev));
   } else {
     attrs.set(attr);
   }
   return *symbol;
 }
 
 static bool NeedsExplicitType(const Symbol &symbol) {
   if (symbol.has<UnknownDetails>()) {

flang/lib/Semantics/tools.cpp

if (const auto *generic{ultimate.detailsIf<GenericDetails>()}) {
     return generic->kind().IsDefinedOperator();
   } else if (const auto *misc{ultimate.detailsIf<MiscDetails>()}) {
     return misc->kind() == MiscDetails::Kind::TypeBoundDefinedOp;
   } else {
     return false;
   }
 }
 
+bool IsDefinedOperator(SourceName name) {
+  const char *begin{name.begin()};
+  const char *end{name.end()};
+  return begin != end && begin[0] == '.' && end[-1] == '.';
+}
+
+std::string MakeOpName(SourceName name) {
+  std::string result{name.ToString()};
+  return IsDefinedOperator(name)         ? "OPERATOR(" + result + ")"
+      : result.find("operator(", 0) == 0 ? parser::ToUpperCaseLetters(result)
+                                         : result;
+}
+
 bool IsCommonBlockContaining(const Symbol &block, const Symbol &object) {
   const auto &objects{block.get<CommonBlockDetails>().objects()};
   auto found{std::find(objects.begin(), objects.end(), object)};
   return found != objects.end();
 }
 
 bool IsUseAssociated(const Symbol &symbol, const Scope &scope) {
   const Scope *owner{FindProgramUnitContaining(symbol.GetUltimate().owner())};

flang/test/Semantics/resolve11.f90

 ! RUN: %S/test_errors.sh %s %t %f18
 module m
   public i
   integer, private :: j
   !ERROR: The accessibility of 'i' has already been specified as PUBLIC
   private i
   !The accessibility of 'j' has already been specified as PRIVATE
   private j
 end
 
 module m2
   interface operator(.foo.)
     module procedure ifoo
   end interface
   public :: operator(.foo.)
-  !ERROR: The accessibility of operator '.foo.' has already been specified as PUBLIC
+  !ERROR: The accessibility of 'OPERATOR(.foo.)' has already been specified as PUBLIC
   private :: operator(.foo.)
   interface operator(+)
     module procedure ifoo
   end interface
   public :: operator(+)
-  !ERROR: The accessibility of 'operator(+)' has already been specified as PUBLIC
+  !ERROR: The accessibility of 'OPERATOR(+)' has already been specified as PUBLIC
   private :: operator(+) , ifoo
 contains
   integer function ifoo(x, y)
     logical, intent(in) :: x, y
   end
 end module
 
 module m3
   type t
   end type
   private :: operator(.lt.)
   interface operator(<)
     logical function lt(x, y)
       import t
       type(t), intent(in) :: x, y
     end function
   end interface
-  !ERROR: The accessibility of 'operator(<)' has already been specified as PRIVATE
+  !ERROR: The accessibility of 'OPERATOR(<)' has already been specified as PRIVATE
   public :: operator(<)
   interface operator(.gt.)
     logical function gt(x, y)
       import t
       type(t), intent(in) :: x, y
     end function
   end interface
   public :: operator(>)
-  !ERROR: The accessibility of 'operator(.gt.)' has already been specified as PUBLIC
+  !ERROR: The accessibility of 'OPERATOR(.GT.)' has already been specified as PUBLIC
   private :: operator(.gt.)
 end

flang/test/Semantics/resolve13.f90

 end
 
 use m1, local_x => x
 !ERROR: 'y' is PRIVATE in 'm1'
 use m1, local_y => y
 !ERROR: 'z' not found in module 'm1'
 use m1, local_z => z
 use m1, operator(.localfoo.) => operator(.foo.)
-!ERROR: Operator '.bar.' not found in module 'm1'
+!ERROR: 'OPERATOR(.bar.)' not found in module 'm1'
 use m1, operator(.localbar.) => operator(.bar.)
 
 !ERROR: 'y' is PRIVATE in 'm1'
 use m1, only: y
-!ERROR: Operator '.priv.' is PRIVATE in 'm1'
+!ERROR: 'OPERATOR(.priv.)' is PRIVATE in 'm1'
 use m1, only: operator(.priv.)
-!ERROR: 'operator(*)' is PRIVATE in 'm1'
+!ERROR: 'OPERATOR(*)' is PRIVATE in 'm1'
 use m1, only: operator(*)
 !ERROR: 'z' not found in module 'm1'
 use m1, only: z
 !ERROR: 'z' not found in module 'm1'
 use m1, only: my_x => z
 use m1, only: operator(.foo.)
-!ERROR: Operator '.bar.' not found in module 'm1'
+!ERROR: 'OPERATOR(.bar.)' not found in module 'm1'
 use m1, only: operator(.bar.)
 use m1, only: operator(-) , ifoo
-!ERROR: 'operator(+)' not found in module 'm1'
+!ERROR: 'OPERATOR(+)' not found in module 'm1'
 use m1, only: operator(+)
 
 end

flang/test/Semantics/resolve15.f90

 ! RUN: %S/test_errors.sh %s %t %f18
 module m
   real :: var
   interface i
     !ERROR: 'var' is not a subprogram
     procedure :: sub, var
     !ERROR: Procedure 'bad' not found
     procedure :: bad
   end interface
   interface operator(.foo.)
     !ERROR: 'var' is not a subprogram
-    procedure :: sub, var
+    procedure :: var
+    !ERROR: OPERATOR(.foo.) procedure 'sub' must be a function
+    procedure :: sub
     !ERROR: Procedure 'bad' not found
     procedure :: bad
   end interface
 contains
   subroutine sub
   end
 end
 

flang/test/Semantics/resolve25.f90

 ! RUN: %S/test_errors.sh %s %t %f18
 module m
   interface foo
-    subroutine s1(x)
+    real function s1(x)
       real x
     end
     !ERROR: 's2' is not a module procedure
     module procedure s2
     !ERROR: Procedure 's3' not found
     procedure s3
     !ERROR: Procedure 's1' is already specified in generic 'foo'
     procedure s1
   end interface
   interface
-    subroutine s4(x,y)
-      real x,y
-    end subroutine
-    subroutine s2(x,y)
-      complex x,y
-    end subroutine
+    real function s4(x,y)
+      real, intent(in) :: x,y
+    end function
+    complex function s2(x,y)
+      complex, intent(in) :: x,y
+    end function
   end interface
   generic :: bar => s4
   generic :: bar => s2
   !ERROR: Procedure 's4' is already specified in generic 'bar'
   generic :: bar => s4
 
   generic :: operator(.foo.)=> s4
   generic :: operator(.foo.)=> s2
-  !ERROR: Procedure 's4' is already specified in generic operator '.foo.'
+  !ERROR: Procedure 's4' is already specified in generic 'OPERATOR(.foo.)'
   generic :: operator(.foo.)=> s4
 end module
 
 module m2
   interface
     integer function f(x, y)
       logical, intent(in) :: x, y
     end function
   end interface
   generic :: operator(+)=> f
-  !ERROR: Procedure 'f' is already specified in generic 'operator(+)'
+  !ERROR: Procedure 'f' is already specified in generic 'OPERATOR(+)'
   generic :: operator(+)=> f
 end
 
 module m3
   interface operator(.ge.)
     procedure f
   end interface
   interface operator(>=)
-    !ERROR: Procedure 'f' is already specified in generic 'operator(.ge.)'
+    !ERROR: Procedure 'f' is already specified in generic 'OPERATOR(.GE.)'
     procedure f
   end interface
   generic :: operator(>) => f
-  !ERROR: Procedure 'f' is already specified in generic 'operator(>)'
+  !ERROR: Procedure 'f' is already specified in generic 'OPERATOR(>)'
   generic :: operator(.gt.) => f
 contains
   logical function f(x, y) result(result)
     logical, intent(in) :: x, y
     result = .true.
   end
 end

flang/test/Semantics/resolve53.f90

 end
 
 ! Check user-defined operators
 module m14
   interface operator(*)
     module procedure f1
     module procedure f2
   end interface
-  !ERROR: Generic 'operator(+)' may not have specific procedures 'f1' and 'f3' as their interfaces are not distinguishable
+  !ERROR: Generic 'OPERATOR(+)' may not have specific procedures 'f1' and 'f3' as their interfaces are not distinguishable
   interface operator(+)
     module procedure f1
     module procedure f3
   end interface
   interface operator(.foo.)
     module procedure f1
     module procedure f2
   end interface
-  !ERROR: Generic operator '.bar.' may not have specific procedures 'f1' and 'f3' as their interfaces are not distinguishable
+  !ERROR: Generic 'OPERATOR(.bar.)' may not have specific procedures 'f1' and 'f3' as their interfaces are not distinguishable
   interface operator(.bar.)
     module procedure f1
     module procedure f3
   end interface
 contains
   real function f1(x, y)
     real, intent(in) :: x
     logical, intent(in) :: y
contains
   subroutine s8(x)
     type(t3(1, :, 3, :, 2, :, 4)), allocatable :: x
   end subroutine
   subroutine s9(x)
     type(t3(k1=2)) :: x
   end subroutine
 end
 
-
 ! Check that specifics for type-bound generics can be distinguished
 module m16
   type :: t
   contains
     procedure, nopass :: s1
     procedure, nopass :: s2
     procedure, nopass :: s3
     generic :: g1 => s1, s2

 end
 
 ! C1511 - rules for operators
 module m19
   interface operator(.foo.)
     module procedure f1
     module procedure f2
   end interface
-  !ERROR: Generic operator '.bar.' may not have specific procedures 'f2' and 'f3' as their interfaces are not distinguishable
+  !ERROR: Generic 'OPERATOR(.bar.)' may not have specific procedures 'f2' and 'f3' as their interfaces are not distinguishable
   interface operator(.bar.)
     module procedure f2
     module procedure f3
   end interface
 contains
   integer function f1(i)
-    integer :: i
+    integer, intent(in) :: i
   end
   integer function f2(i, j)
-    integer :: i, j
+    integer, value :: i, j
   end
   integer function f3(i, j)
-    integer :: i, j
+    integer, intent(in) :: i, j
   end
 end
 
 module m20
   interface operator(.not.)
     real function f(x)
       character(*),intent(in) :: x
     end function
   end interface
   interface operator(+)
     procedure f
   end interface
 end module
 
 subroutine s1()
   use m20
   interface operator(.not.)
-    !ERROR: Procedure 'f' is already specified in generic 'operator(.not.)'
+    !ERROR: Procedure 'f' is already specified in generic 'OPERATOR(.NOT.)'
     procedure f
   end interface
   interface operator(+)
-    !ERROR: Procedure 'f' is already specified in generic 'operator(+)'
+    !ERROR: Procedure 'f' is already specified in generic 'OPERATOR(+)'
     procedure f
   end interface
 end subroutine s1

flang/test/Semantics/resolve96.f90

+! RUN: %S/test_errors.sh %s %t %f18
+
+! Check distinguishability for specific procedures of defined operators and
+! assignment. These are different from names because there a normal generic
+! is invoked the same way as a type-bound generic.
+! E.g. for a generic name like 'foo', the generic name is invoked as 'foo(x, y)'
+! while the type-bound generic is invoked as 'x%foo(y)'.
+! But for 'operator(.foo.)', it is 'x .foo. y' in either case.
+! So to check the specifics of 'operator(.foo.)' we have to consider all
+! definitions of it visible in the current scope.
+
+! One operator(.foo.) comes from interface-stmt, the other is type-bound.
+module m1
+  type :: t1
+  contains
+    procedure, pass :: p => s1
+    generic :: operator(.foo.) => p
+  end type
+  type :: t2
+  end type
+  !ERROR: Generic 'OPERATOR(.foo.)' may not have specific procedures 's2' and 't1%p' as their interfaces are not distinguishable
+  interface operator(.foo.)
+    procedure :: s2
+  end interface
+contains
+  integer function s1(x1, x2)
+    class(t1), intent(in) :: x1
+    class(t2), intent(in) :: x2
+  end
+  integer function s2(x1, x2)
+    class(t1), intent(in) :: x1
+    class(t2), intent(in) :: x2
+  end
+end module
+
+! assignment(=) as type-bound generic in each type
+module m2
+  type :: t1
+    integer :: n
+  contains
+    procedure, pass(x1) :: p1 => s1
+    !ERROR: Generic 'assignment(=)' may not have specific procedures 't1%p1' and 't2%p2' as their interfaces are not distinguishable
+    generic :: assignment(=) => p1
+  end type
+  type :: t2
+    integer :: n
+  contains
+    procedure, pass(x2) :: p2 => s2
+    generic :: assignment(=) => p2
+  end type
+contains
+  subroutine s1(x1, x2)
+    class(t1), intent(out) :: x1
+    class(t2), intent(in) :: x2
+    x1%n = x2%n + 1
+  end subroutine
+  subroutine s2(x1, x2)
+    class(t1), intent(out) :: x1
+    class(t2), intent(in) :: x2
+    x1%n = x2%n + 2
+  end subroutine
+end module

flang/test/Semantics/test_errors.sh

 #!/usr/bin/env bash
 # Compile a source file and check errors against those listed in the file.
 # Change the compiler by setting the F18 environment variable.
 
-F18_OPTIONS="-fdebug-resolve-names -fparse-only"
+F18_OPTIONS="-fparse-only"
 srcdir=$(dirname $0)
 source $srcdir/common.sh
 [[ ! -f $src ]] && die "File not found: $src"
 
 log=$temp/log
 actual=$temp/actual
 expect=$temp/expect
 diffs=$temp/diffs