[flang] Handle multiple names for same operator

[tskeith]

Summary

Some operators have more than one name, e.g. operator(==), operator(.eq).
That was working correctly in generic definitions but they can also
appear in other contexts: USE statements and access statements, for
example.

This changes FindInScope to always look for each of the names for
a symbol. So an operator may be use-associated under one name but
declared private under another name and it will be the same symbol.
This replaces GenericSpecInfo::FindInScope which was only usable in
some cases.

Add a version of FindInScope() that looks in the current scope to
simplify many of the calls.

[tskeith]

Note: this change depends on D93343

[PeteSteinfeld]

I'm not sure how to layer one patch on top of another. I tried doing an "arc patch D93343" followed by "arc patch D93344". The second command said that it successfully committed the patch, but then it said "Cherry Pick Failed!" How do I combine both patches?

[klausler]

Could the same effect be accomplished by instead canonicalizing operator(...) names in the output of the prescanner?

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

32

This might be an instance of a static variable with a nontrivial constructor, which is typically verboten in LLVM. Can you make it constexpr instead?

167

Is this code just for debugging during development?

flang/lib/Semantics/resolve-names.cpp

505

This template seems to just call one of the two overloads declared beforehand, and may not be necessary.

[tskeith]

In D93344#2456531, @klausler wrote:

Could the same effect be accomplished by instead canonicalizing operator(...) names in the output of the prescanner?

Yes, and that would simplify life in resolve-names.cpp. But it would mean that a user that consistently used operator(==), for example, might get diagnostics that refer to operator(.eq.) (or vice versa, depending on how we canonicalized). As it is, we use one of the names that appears in the source.

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

32

I tried that but with clang 9 I get:
error: constexpr variable cannot have non-literal type 'const std::string'

I can change it to static constexpr const char * and create the string when needed.

167

Yes, like lots of other instances of operator<<.

flang/lib/Semantics/resolve-names.cpp

505

It passes in the current scope so we can call FindInScope on a parser::Name or SourceName without passing in a Scope.

[tskeith]

In D93344#2456477, @PeteSteinfeld wrote:

I'm not sure how to layer one patch on top of another. I tried doing an "arc patch D93343" followed by "arc patch D93344". The second command said that it successfully committed the patch, but then it said "Cherry Pick Failed!" How do I combine both patches?

I don't know, but now D93343 has been submitted so you should be able to arc patch on top of the latest on main.

[klausler]

In D93344#2456607, @tskeith wrote:

In D93344#2456531, @klausler wrote:

Could the same effect be accomplished by instead canonicalizing operator(...) names in the output of the prescanner?

Yes, and that would simplify life in resolve-names.cpp. But it would mean that a user that consistently used operator(==), for example, might get diagnostics that refer to operator(.eq.) (or vice versa, depending on how we canonicalized). As it is, we use one of the names that appears in the source.

Sure, but we would still be quoting and underlining the original source, so the user experience wouldn't be a total loss. Let me know if this is something that you'd like me to try to do.

[tskeith]

Make operatorPrefix constexpr.

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

 #include "flang/Evaluate/fold.h"
 #include "flang/Parser/message.h"
 #include "flang/Parser/tools.h"
 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/scope.h"
 #include "flang/Semantics/semantics.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/type.h"
+#include "llvm/Support/raw_ostream.h"
 #include <forward_list>
 
 namespace Fortran::parser {
 class CharBlock;
 struct ArraySpec;
 struct CoarraySpec;
 struct ComponentArraySpec;
 struct DataRef;

 
 // Create a copy of msg with a new isFatal value.
 parser::MessageFixedText WithIsFatal(
     const parser::MessageFixedText &msg, bool isFatal);
 
 bool IsIntrinsicOperator(const SemanticsContext &, const SourceName &);
 bool IsLogicalConstant(const SemanticsContext &, const SourceName &);
 
+// Some intrinsic operators have more than one name (e.g. `operator(.eq.)` and
+// `operator(==)`). GetAllNames() returns them all, including symbolName.
+std::forward_list<std::string> GetAllNames(
+    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)}) {
       return std::move(*intExpr);
     }
   }

 // Analyze a generic-spec and generate a symbol name and GenericKind for it.
 class GenericSpecInfo {
 public:
   GenericSpecInfo(const parser::DefinedOpName &x) { Analyze(x); }
   GenericSpecInfo(const parser::GenericSpec &x) { Analyze(x); }
 
   GenericKind kind() const { return kind_; }
   const SourceName &symbolName() const { return symbolName_.value(); }
-  // Some intrinsic operators have more than one name (e.g. `operator(.eq.)` and
-  // `operator(==)`). GetAllNames() returns them all, including symbolName.
-  std::forward_list<std::string> GetAllNames(SemanticsContext &) const;
   // Set the GenericKind in this symbol and resolve the corresponding
   // name if there is one
   void Resolve(Symbol *) const;
-  Symbol *FindInScope(SemanticsContext &, const Scope &) const;
+  friend llvm::raw_ostream &operator<<(
+      llvm::raw_ostream &, const GenericSpecInfo &);
 
 private:
   GenericKind kind_;
   const parser::Name *parseName_{nullptr};
   std::optional<SourceName> symbolName_;
 
   void Analyze(const parser::DefinedOpName &);
   void Analyze(const parser::GenericSpec &);

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

 namespace Fortran::semantics {
 
 using common::LanguageFeature;
 using common::LogicalOperator;
 using common::NumericOperator;
 using common::RelationalOperator;
 using IntrinsicOperator = parser::DefinedOperator::IntrinsicOperator;
 
+static const std::string operatorPrefix{"operator("};
+
 static GenericKind MapIntrinsicOperator(IntrinsicOperator);
 
 Symbol *Resolve(const parser::Name &name, Symbol *symbol) {
   if (symbol && !name.symbol) {
     name.symbol = symbol;
   }
   return symbol;
 }
for (int i{0}; i != common::RelationalOperator_enumSize; ++i) {
     auto names{context.languageFeatures().GetNames(RelationalOperator{i})};
     if (std::find(names.begin(), names.end(), str) != names.end()) {
       return true;
     }
   }
   return false;
 }
 
-bool IsLogicalConstant(
-    const SemanticsContext &context, const SourceName &name) {
-  std::string str{name.ToString()};
-  return str == ".true." || str == ".false." ||
-      (context.IsEnabled(LanguageFeature::LogicalAbbreviations) &&
-          (str == ".t" || str == ".f."));
-}
-
-// The operators <, <=, >, >=, ==, and /= always have the same interpretations
-// as the operators .LT., .LE., .GT., .GE., .EQ., and .NE., respectively.
-std::forward_list<std::string> GenericSpecInfo::GetAllNames(
-    SemanticsContext &context) const {
-  auto getNames{[&](auto opr) {
-    std::forward_list<std::string> result;
-    for (const char *name : context.languageFeatures().GetNames(opr)) {
-      result.emplace_front("operator("s + name + ')');
-    }
-    return result;
-  }};
-  return std::visit(
-      common::visitors{[&](const LogicalOperator &x) { return getNames(x); },
-          [&](const RelationalOperator &x) { return getNames(x); },
-          [&](const auto &) -> std::forward_list<std::string> {
-            return {symbolName_.value().ToString()};
-          }},
-      kind_.u);
+template <typename E>
+std::forward_list<std::string> GetOperatorNames(
+    const SemanticsContext &context, E opr) {
+    result.emplace_front(operatorPrefix + name + ')');
 }
 
-Symbol *GenericSpecInfo::FindInScope(
-    SemanticsContext &context, const Scope &scope) const {
-  for (const auto &name : GetAllNames(context)) {
-    auto iter{scope.find(SourceName{name})};
-    if (iter != scope.end()) {
-      return &*iter->second;
+std::forward_list<std::string> GetAllNames(
+    const SemanticsContext &context, const SourceName &name) {
+  std::string str{name.ToString()};
+  if (!name.empty() && name.end()[-1] == ')' &&
+      name.ToString().rfind(operatorPrefix, 0) == 0) {
+    for (int i{0}; i != common::LogicalOperator_enumSize; ++i) {
+      auto names{GetOperatorNames(context, LogicalOperator{i})};
+      if (std::find(names.begin(), names.end(), str) != names.end()) {
+        return names;
+      }
+    }
+    for (int i{0}; i != common::RelationalOperator_enumSize; ++i) {
+      auto names{GetOperatorNames(context, RelationalOperator{i})};
+      if (std::find(names.begin(), names.end(), str) != names.end()) {
+        return names;
       }
     }
-  return nullptr;
+  }
+  return {str};
+}
+
+bool IsLogicalConstant(
+    const SemanticsContext &context, const SourceName &name) {
+  std::string str{name.ToString()};
+  return str == ".true." || str == ".false." ||
+      (context.IsEnabled(LanguageFeature::LogicalAbbreviations) &&
+          (str == ".t" || str == ".f."));
 }
 
 void GenericSpecInfo::Resolve(Symbol *symbol) const {
   if (symbol) {
     if (auto *details{symbol->detailsIf<GenericDetails>()}) {
       details->set_kind(kind_);
     }
     if (parseName_) {
kind_ = std::visit(
           },
           [&](const parser::GenericSpec::WriteUnformatted &) -> GenericKind {
             return GenericKind::DefinedIo::WriteUnformatted;
           },
       },
       x.u);
 }
 
+llvm::raw_ostream &operator<<(
+    llvm::raw_ostream &os, const GenericSpecInfo &info) {
+  os << "GenericSpecInfo: kind=" << info.kind_.ToString();
+  os << " parseName="
+     << (info.parseName_ ? info.parseName_->ToString() : "null");
+  os << " symbolName="
+     << (info.symbolName_ ? info.symbolName_->ToString() : "null");
+  return os;
+}
+
 // parser::DefinedOperator::IntrinsicOperator -> GenericKind
 static GenericKind MapIntrinsicOperator(IntrinsicOperator op) {
   switch (op) {
     SWITCH_COVERS_ALL_CASES
   case IntrinsicOperator::Concat:
     return GenericKind::OtherKind::Concat;
   case IntrinsicOperator::Power:
     return NumericOperator::Power;

flang/lib/Semantics/resolve-names.cpp

public:
 
   // Search for symbol by name in current, parent derived type, and
   // containing scopes
   Symbol *FindSymbol(const parser::Name &);
   Symbol *FindSymbol(const Scope &, const parser::Name &);
   // Search for name only in scope, not in enclosing scopes.
   Symbol *FindInScope(const Scope &, const parser::Name &);
   Symbol *FindInScope(const Scope &, const SourceName &);
+  template <typename T> Symbol *FindInScope(const T &name) {
+    return FindInScope(currScope(), name);
+  }
   // Search for name in a derived type scope and its parents.
   Symbol *FindInTypeOrParents(const Scope &, const parser::Name &);
   Symbol *FindInTypeOrParents(const parser::Name &);
   void EraseSymbol(const parser::Name &);
   void EraseSymbol(const Symbol &symbol) { currScope().erase(symbol.name()); }
   // Make a new symbol with the name and attrs of an existing one
   Symbol &CopySymbol(const SourceName &, const Symbol &);
 
common::IfNoLvalue<Symbol &, D> MakeSymbol(
     return Resolve(name, MakeSymbol(name.source, attrs, std::move(details)));
   }
 
   template <typename D>
   common::IfNoLvalue<Symbol &, D> MakeSymbol(
       const SourceName &name, const Attrs &attrs, D &&details) {
     // Note: don't use FindSymbol here. If this is a derived type scope,
     // we want to detect whether the name is already declared as a component.
-    auto *symbol{FindInScope(currScope(), name)};
+    auto *symbol{FindInScope(name)};
     if (!symbol) {
       symbol = &MakeSymbol(name, attrs);
       symbol->set_details(std::move(details));
       return *symbol;
     }
     if constexpr (std::is_same_v<DerivedTypeDetails, D>) {
       if (auto *d{symbol->detailsIf<GenericDetails>()}) {
         if (!d->specific()) {
Symbol &ScopeHandler::MakeHostAssocSymbol(
     const parser::Name &name, const Symbol &hostSymbol) {
   Symbol &symbol{MakeSymbol(name, HostAssocDetails{hostSymbol})};
   name.symbol = &symbol;
   symbol.attrs() = hostSymbol.attrs(); // TODO: except PRIVATE, PUBLIC?
   symbol.flags() = hostSymbol.flags();
   return symbol;
 }
 Symbol &ScopeHandler::CopySymbol(const SourceName &name, const Symbol &symbol) {
-  CHECK(!FindInScope(currScope(), name));
+  CHECK(!FindInScope(name));
   return MakeSymbol(currScope(), name, symbol.attrs());
 }
 
 // Look for name only in scope, not in enclosing scopes.
 Symbol *ScopeHandler::FindInScope(
     const Scope &scope, const parser::Name &name) {
   return Resolve(name, FindInScope(scope, name.source));
 }
 Symbol *ScopeHandler::FindInScope(const Scope &scope, const SourceName &name) {
-  if (auto it{scope.find(name)}; it != scope.end()) {
+  // all variants of names, e.g. "operator(.ne.)" for "operator(/=)"
+  for (const std::string &n : GetAllNames(context(), name)) {
+    auto it{scope.find(SourceName{n})};
+    if (it != scope.end()) {
       return &*it->second;
-  } else {
-    return nullptr;
     }
   }
+  return nullptr;
+}
 
 // Find a component or type parameter by name in a derived type or its parents.
 Symbol *ScopeHandler::FindInTypeOrParents(
     const Scope &scope, const parser::Name &name) {
   return Resolve(name, scope.FindComponent(name.source));
 }
 Symbol *ScopeHandler::FindInTypeOrParents(const parser::Name &name) {
   return FindInTypeOrParents(currScope(), name);
for (const auto &rename : *list) {
                  },
           rename.u);
     }
     for (const auto &[name, symbol] : *useModuleScope_) {
       if (symbol->attrs().test(Attr::PUBLIC) &&
           !symbol->attrs().test(Attr::INTRINSIC) &&
           !symbol->has<MiscDetails>() && useNames.count(name) == 0) {
         SourceName location{x.moduleName.source};
-        if (auto *localSymbol{FindInScope(currScope(), name)}) {
+        if (auto *localSymbol{FindInScope(name)}) {
           DoAddUse(location, localSymbol->name(), *localSymbol, *symbol);
         } else {
           DoAddUse(location, location, CopySymbol(name, *symbol), *symbol);
         }
       }
     }
   }
   useModuleScope_ = nullptr;
if (localUltimate == useUltimate) {
             " from modules '%s' and '%s'"_err_en_US,
             localSymbol.name(), GetUsedModule(*useDetails).name(),
             useUltimate.owner().GetName().value());
         context().SetError(localSymbol);
       } else {
         generic1.CopyFrom(generic2);
       }
       EraseSymbol(localSymbol);
-      MakeSymbol(
-          localSymbol.name(), localUltimate.attrs(), std::move(generic1));
+      MakeSymbol(localSymbol.name(), localSymbol.attrs(), std::move(generic1));
     } else {
       ConvertToUseError(localSymbol, location, *useModuleScope_);
     }
   } else if (auto *genericDetails{localSymbol.detailsIf<GenericDetails>()}) {
     if (const auto *useDetails{useUltimate.detailsIf<GenericDetails>()}) {
       AddGenericUse(*genericDetails, localName, useUltimate);
       if (genericDetails->derivedType() && useDetails->derivedType() &&
           genericDetails->derivedType() != useDetails->derivedType()) {
void ModuleVisitor::DoAddUse(const SourceName &location,
   } else {
     localSymbol.set_details(UseDetails{localName, useSymbol});
   }
 }
 
 void ModuleVisitor::AddUse(const GenericSpecInfo &info) {
   if (useModuleScope_) {
     const auto &name{info.symbolName()};
-    auto rename{
-        AddUse(name, name, info.FindInScope(context(), *useModuleScope_))};
+    auto rename{AddUse(name, name, FindInScope(*useModuleScope_, name))};
     info.Resolve(rename.use);
   }
 }
 
 // Create a UseDetails symbol for this USE and add it to generic
 void ModuleVisitor::AddGenericUse(
     GenericDetails &generic, const SourceName &name, const Symbol &useSymbol) {
   generic.AddUse(currScope().MakeSymbol(name, {}, UseDetails{name, useSymbol}));

 void InterfaceVisitor::Post(const parser::InterfaceStmt &) { EndAttrs(); }
 
 void InterfaceVisitor::Post(const parser::EndInterfaceStmt &) {
   genericInfo_.pop();
 }
 
 // Create a symbol in genericSymbol_ for this GenericSpec.
 bool InterfaceVisitor::Pre(const parser::GenericSpec &x) {
-  if (auto *symbol{GenericSpecInfo{x}.FindInScope(context(), currScope())}) {
+  if (auto *symbol{FindInScope(GenericSpecInfo{x}.symbolName())}) {
     SetGenericSymbol(*symbol);
   }
   return false;
 }
 
 bool InterfaceVisitor::Pre(const parser::ProcedureStmt &x) {
   if (!isGeneric()) {
     Say("A PROCEDURE statement is only allowed in a generic interface block"_err_en_US);
bool DeclarationVisitor::HandleAttributeStmt(
   }
   return false;
 }
 Symbol &DeclarationVisitor::HandleAttributeStmt(
     Attr attr, const parser::Name &name) {
   if (attr == Attr::INTRINSIC && !IsIntrinsic(name.source, std::nullopt)) {
     Say(name.source, "'%s' is not a known intrinsic procedure"_err_en_US);
   }
-  auto *symbol{FindInScope(currScope(), name)};
+  auto *symbol{FindInScope(name)};
   if (attr == Attr::ASYNCHRONOUS || attr == Attr::VOLATILE) {
     // these can be set on a symbol that is host-assoc or use-assoc
     if (!symbol &&
         (currScope().kind() == Scope::Kind::Subprogram ||
             currScope().kind() == Scope::Kind::Block)) {
       if (auto *hostSymbol{FindSymbol(name)}) {
         symbol = &MakeHostAssocSymbol(name, *hostSymbol);
       }
void DeclarationVisitor::Post(
   }
 }
 
 void DeclarationVisitor::CheckBindings(
     const parser::TypeBoundProcedureStmt::WithoutInterface &tbps) {
   CHECK(currScope().IsDerivedType());
   for (auto &declaration : tbps.declarations) {
     auto &bindingName{std::get<parser::Name>(declaration.t)};
-    if (Symbol * binding{FindInScope(currScope(), bindingName)}) {
+    if (Symbol * binding{FindInScope(bindingName)}) {
       if (auto *details{binding->detailsIf<ProcBindingDetails>()}) {
         const Symbol *procedure{FindSubprogram(details->symbol())};
         if (!CanBeTypeBoundProc(procedure)) {
           if (details->symbol().name() != binding->name()) {
             Say(binding->name(),
                 "The binding of '%s' ('%s') must be either an accessible "
                 "module procedure or an external procedure with "
                 "an explicit interface"_err_en_US,

 bool DeclarationVisitor::Pre(const parser::TypeBoundGenericStmt &x) {
   const auto &accessSpec{std::get<std::optional<parser::AccessSpec>>(x.t)};
   const auto &genericSpec{std::get<Indirection<parser::GenericSpec>>(x.t)};
   const auto &bindingNames{std::get<std::list<parser::Name>>(x.t)};
   auto info{GenericSpecInfo{genericSpec.value()}};
   SourceName symbolName{info.symbolName()};
   bool isPrivate{accessSpec ? accessSpec->v == parser::AccessSpec::Kind::Private
                             : derivedTypeInfo_.privateBindings};
-  auto *genericSymbol{info.FindInScope(context(), currScope())};
+  auto *genericSymbol{FindInScope(symbolName)};
   if (genericSymbol) {
     if (!genericSymbol->has<GenericDetails>()) {
       genericSymbol = nullptr; // MakeTypeSymbol will report the error below
     }
   } else {
     // look in parent types:
     Symbol *inheritedSymbol{nullptr};
-    for (const auto &name : info.GetAllNames(context())) {
+    for (const auto &name : GetAllNames(context(), symbolName)) {
       inheritedSymbol = currScope().FindComponent(SourceName{name});
       if (inheritedSymbol) {
         break;
       }
     }
     if (inheritedSymbol && inheritedSymbol->has<GenericDetails>()) {
       CheckAccessibility(symbolName, isPrivate, *inheritedSymbol); // C771
     }
for (const auto &name : std::get<std::list<parser::Name>>(x.t)) {
     } else if (!ConvertToObjectEntity(*symbol)) {
       SayWithDecl(name, *symbol, "'%s' is not a variable"_err_en_US);
     }
     symbol->GetUltimate().set(Symbol::Flag::InNamelist);
     details.add_object(*symbol);
   }
 
   const auto &groupName{std::get<parser::Name>(x.t)};
-  auto *groupSymbol{FindInScope(currScope(), groupName)};
+  auto *groupSymbol{FindInScope(groupName)};
   if (!groupSymbol || !groupSymbol->has<NamelistDetails>()) {
     groupSymbol = &MakeSymbol(groupName, std::move(details));
     groupSymbol->ReplaceName(groupName.source);
   }
   groupSymbol->get<NamelistDetails>().add_objects(details.objects());
   return false;
 }
 
for (const parser::SavedEntity &y : x.v) {
       }
     }
   }
   return false;
 }
 
 void DeclarationVisitor::CheckSaveStmts() {
   for (const SourceName &name : saveInfo_.entities) {
-    auto *symbol{FindInScope(currScope(), name)};
+    auto *symbol{FindInScope(name)};
     if (!symbol) {
       // error was reported
     } else if (saveInfo_.saveAll) {
       // C889 - note that pgi, ifort, xlf do not enforce this constraint
       Say2(name,
           "Explicit SAVE of '%s' is redundant due to global SAVE statement"_err_en_US,
           *saveInfo_.saveAll, "Global SAVE statement"_en_US);
     } else if (auto msg{CheckSaveAttr(*symbol)}) {
bool ConstructVisitor::Pre(const parser::ChangeTeamStmt &x) {
   PushScope(Scope::Kind::Block, nullptr);
   PushAssociation();
   return true;
 }
 
 void ConstructVisitor::Post(const parser::CoarrayAssociation &x) {
   const auto &decl{std::get<parser::CodimensionDecl>(x.t)};
   const auto &name{std::get<parser::Name>(decl.t)};
-  if (auto *symbol{FindInScope(currScope(), name)}) {
+  if (auto *symbol{FindInScope(name)}) {
     const auto &selector{std::get<parser::Selector>(x.t)};
     if (auto sel{ResolveSelector(selector)}) {
       const Symbol *whole{UnwrapWholeSymbolDataRef(sel.expr)};
       if (!whole || whole->Corank() == 0) {
         Say(sel.source, // C1116
             "Selector in coarray association must name a coarray"_err_en_US);
       } else if (auto dynType{sel.expr->GetType()}) {
         if (!symbol->GetType()) {
for (const auto &accessId : accessIds) {
       std::visit(
           common::visitors{
               [=](const parser::Name &y) {
                 Resolve(y, SetAccess(y.source, accessAttr));
               },
               [=](const Indirection<parser::GenericSpec> &y) {
                 auto info{GenericSpecInfo{y.value()}};
                 const auto &symbolName{info.symbolName()};
-                if (auto *symbol{info.FindInScope(context(), currScope())}) {
+                if (auto *symbol{FindInScope(symbolName)}) {
                   info.Resolve(&SetAccess(symbolName, accessAttr, symbol));
                 } else if (info.kind().IsName()) {
                   info.Resolve(&SetAccess(symbolName, accessAttr));
                 } else {
                   Say(symbolName, "Generic spec '%s' not found"_err_en_US);
                 }
               },
           },
void ResolveNamesVisitor::CreateGeneric(const parser::GenericSpec &x) {
   auto info{GenericSpecInfo{x}};
   const SourceName &symbolName{info.symbolName()};
   if (IsLogicalConstant(context(), symbolName)) {
     Say(symbolName,
         "Logical constant '%s' may not be used as a defined operator"_err_en_US);
     return;
   }
   GenericDetails genericDetails;
-  if (Symbol * existing{info.FindInScope(context(), currScope())}) {
+  if (Symbol * existing{FindInScope(symbolName)}) {
     if (existing->has<GenericDetails>()) {
       info.Resolve(existing);
       return; // already have generic, add to it
     }
     Symbol &ultimate{existing->GetUltimate()};
     if (auto *ultimateDetails{ultimate.detailsIf<GenericDetails>()}) {
       // convert a use-associated generic into a local generic
       genericDetails.CopyFrom(*ultimateDetails);
for (auto &name : scope.importNames()) {
       CheckImport(name, name);
     }
     break;
   }
 }
 
 void ResolveNamesVisitor::CheckImport(
     const SourceName &location, const SourceName &name) {
-  if (auto *symbol{FindInScope(currScope(), name)}) {
+  if (auto *symbol{FindInScope(name)}) {
     Say(location, "'%s' from host is not accessible"_err_en_US, name)
         .Attach(symbol->name(), "'%s' is hidden by this entity"_en_US,
             symbol->name());
   }
 }
 
 bool ResolveNamesVisitor::Pre(const parser::ImplicitStmt &x) {
   return CheckNotInBlock("IMPLICIT") && // C1107

flang/test/Semantics/modfile07.f90

 !contains
 ! subroutine s(x)
 !   real(4)::x
 ! end
 ! subroutine test()
 ! end
 !end
 
+! Verify that equivalent names are used when generic operators are merged
+
+module m10a
+  interface operator(.ne.)
+  end interface
+end
+!Expect: m10a.mod
+!module m10a
+! interface operator(.ne.)
+! end interface
+!end
+
+module m10b
+  interface operator(<>)
+  end interface
+end
+!Expect: m10b.mod
+!module m10b
+! interface operator(<>)
+! end interface
+!end
+
+module m10c
+  use m10a
+  use m10b
+  interface operator(/=)
+  end interface
+end
+!Expect: m10c.mod
+!module m10c
+! use m10b,only:operator(.ne.)
+! use m10a,only:operator(.ne.)
+! interface operator(.ne.)
+! end interface
+!end
+
+module m10d
+  use m10a
+  use m10c
+  private :: operator(<>)
+end
+!Expect: m10d.mod
+!module m10d
+! use m10c,only:operator(.ne.)
+! use m10a,only:operator(.ne.)
+! interface operator(.ne.)
+! end interface
+! private::operator(.ne.)
+!end