[flang] Handle undeclared names in EQUIVALENCE statements

[PeteSteinfeld]

Summary

Names in EQUIVALENCE statements are only allowed to indicate local
objects as per 19.5.1.4, paragraph 2, item (10). Thus, a name appearing
in an EQUIVALENCE statement with no corresponding declaration in the
same scope is an implicit declaration of the name. If that scope
contains an IMPLICIT NONE, it's an error.

I implemented this by adding a state variable to the SemanticsContext to
indicate if we're resolving the names in an EQUIVALENCE statement and
then checked this state when resolving names. I also added a test to
the existing tests for EQUIVALENCE statements.

[klausler]

flang/include/flang/Semantics/scope.h

133

This is really just a convenience wrapper for find(), yes? If so, then either it's redundant with find(), or you should find and replace other uses of find() with your new API and avoid the confusion that can arise with multiple interfaces that do much the same thing. (Preference is for the former, since usage of find() in scopes is pretty idiomatic by this point.)

flang/include/flang/Semantics/semantics.h

88

The SemanticsContext object is probably not the best place for this new state. One of the visitor classes in name resolution would make more sense.

[tskeith]

flang/lib/Semantics/resolve-names.cpp

2024

FindInScope(scope, name.source) does the same thing, so you don't need the new function. (Or replace FindInScope with FindLocalSymbol everywhere.)

4358

I think it makes more sense for inEquivalenceStmt_ to be recorded in ScopeHandler (like inExecutionPart_, for example). It doesn't really belong in SemanticsContext because it only applies to name resolution, not to the rest of semantic analysis.

[tskeith]

Sorry, I didn't see Peter's comments until after I submitted mine.

[PeteSteinfeld]

flang/include/flang/Semantics/scope.h

133

Thanks, Peter. I plan to follow Tim's suggestion below and use the existing

FindInScope()

flang/include/flang/Semantics/semantics.h

88

Thanks. I'll make that change.

flang/lib/Semantics/resolve-names.cpp

2024

I didn't notice

FindInScope()
```.  I'll just use that.

4358

Thanks, Tim. Will do.

[PeteSteinfeld]

Responses to review comments. I moved the state variable indicating if we're
resolving names in an EQUIVALENCE statement to the class ScopeHandler and used
the existing FindInScope() function to limit name loopups to the current scope
rather than inventing a new interface.

flang/include/flang/Semantics/scope.h

public:
 
   iterator find(const SourceName &name);
   const_iterator find(const SourceName &name) const {
     return symbols_.find(name);
   }
   size_type erase(const SourceName &);
   bool empty() const { return symbols_.empty(); }
 
+  // Look for symbol by name only in this scope (for EQUIVALENCE statements)
+  Symbol *FindLocalSymbol(const SourceName &) const;
+
   // Look for symbol by name in this scope and host (depending on imports).
   Symbol *FindSymbol(const SourceName &) const;
 
   // Look for component symbol by name in a derived type's scope and
   // parents'.
   Symbol *FindComponent(SourceName) const;
 
   /// Make a Symbol with unknown details.

flang/include/flang/Semantics/semantics.h

public:
   const std::vector<std::string> &searchDirectories() const {
     return searchDirectories_;
   }
   const std::string &moduleDirectory() const { return moduleDirectory_; }
   const std::string &moduleFileSuffix() const { return moduleFileSuffix_; }
   bool warnOnNonstandardUsage() const { return warnOnNonstandardUsage_; }
   bool warningsAreErrors() const { return warningsAreErrors_; }
   bool debugModuleWriter() const { return debugModuleWriter_; }
+  bool inEquivalenceStmt() { return inEquivalenceStmt_; }
   const evaluate::IntrinsicProcTable &intrinsics() const { return intrinsics_; }
   Scope &globalScope() { return globalScope_; }
   parser::Messages &messages() { return messages_; }
   evaluate::FoldingContext &foldingContext() { return foldingContext_; }
   parser::AllCookedSources &allCookedSources() { return allCookedSources_; }
 
   SemanticsContext &set_location(
       const std::optional<parser::CharBlock> &location) {
public:
   SemanticsContext &set_warnOnNonstandardUsage(bool x) {
     warnOnNonstandardUsage_ = x;
     return *this;
   }
   SemanticsContext &set_warningsAreErrors(bool x) {
     warningsAreErrors_ = x;
     return *this;
   }
+  SemanticsContext &set_inEquivalenceStmt(bool x) {
+    inEquivalenceStmt_ = x;
+    return *this;
+  }
 
   SemanticsContext &set_debugModuleWriter(bool x) {
     debugModuleWriter_ = x;
     return *this;
   }
 
   const DeclTypeSpec &MakeNumericType(TypeCategory, int kind = 0);
   const DeclTypeSpec &MakeLogicalType(int kind = 0);
private:
   Scope globalScope_;
   parser::Messages messages_;
   evaluate::FoldingContext foldingContext_;
   ConstructStack constructStack_;
   struct IndexVarInfo {
     parser::CharBlock location;
     IndexVarKind kind;
   };
+  bool inEquivalenceStmt_{false};
   std::map<SymbolRef, const IndexVarInfo> activeIndexVars_;
   std::set<SymbolRef> errorSymbols_;
   std::vector<std::string> tempNames_;
 };
 
 class Semantics {
 public:
   explicit Semantics(SemanticsContext &context, parser::Program &program,

flang/lib/Semantics/resolve-names.cpp

if (scope.IsDerivedType()) {
     if (Symbol * symbol{scope.FindComponent(name.source)}) {
       if (!symbol->has<ProcBindingDetails>() &&
           !symbol->test(Symbol::Flag::ParentComp)) {
         return Resolve(name, symbol);
       }
     }
     return FindSymbol(scope.parent(), name);
   } else {
-    return Resolve(name, scope.FindSymbol(name.source));
+    // In EQUIVALENCE statements only resolve names in the local scope, see
+    // 19.5.1.4, paragraph 2, item (10)
+    return Resolve(name,
+        context().inEquivalenceStmt() ? scope.FindLocalSymbol(name.source)
+                                      : scope.FindSymbol(name.source));
   }
 }
 
 Symbol &ScopeHandler::MakeSymbol(
     Scope &scope, const SourceName &name, Attrs attrs) {
   if (Symbol * symbol{FindInScope(scope, name)}) {
     symbol->attrs() |= attrs;
     return *symbol;
if (!pair.second) {
     const SourceName &prev{*pair.first};
     Say2(name.source, "'%s' is already in a COMMON block"_err_en_US, prev,
         "Previous occurrence of '%s' in a COMMON block"_en_US);
   }
 }
 
 bool DeclarationVisitor::Pre(const parser::EquivalenceStmt &x) {
   // save equivalence sets to be processed after specification part
-  CheckNotInBlock("EQUIVALENCE"); // C1107
+  if (CheckNotInBlock("EQUIVALENCE")) { // C1107
     for (const std::list<parser::EquivalenceObject> &set : x.v) {
       equivalenceSets_.push_back(&set);
     }
+  }
   return false; // don't implicitly declare names yet
 }
 
 void DeclarationVisitor::CheckEquivalenceSets() {
   EquivalenceSets equivSets{context()};
+  context().set_inEquivalenceStmt(true);
   for (const auto *set : equivalenceSets_) {
     const auto &source{set->front().v.value().source};
     if (set->size() <= 1) { // R871
       Say(source, "Equivalence set must have more than one object"_err_en_US);
     }
     for (const parser::EquivalenceObject &object : *set) {
       const auto &designator{object.v.value()};
       // The designator was not resolved when it was encountered so do it now.
       // AnalyzeExpr causes array sections to be changed to substrings as needed
       Walk(designator);
       if (AnalyzeExpr(context(), designator)) {
         equivSets.AddToSet(designator);
       }
     }
     equivSets.FinishSet(source);
   }
+  context().set_inEquivalenceStmt(false);
   for (auto &set : equivSets.sets()) {
     if (!set.empty()) {
       currScope().add_equivalenceSet(std::move(set));
     }
   }
   equivalenceSets_.clear();
 }
 

flang/lib/Semantics/scope.cpp

 }
 SymbolVector Scope::GetSymbols() const {
   return GetSortedSymbols<const Symbol>(symbols_);
 }
 
 Scope::iterator Scope::find(const SourceName &name) {
   return symbols_.find(name);
 }
+
 Scope::size_type Scope::erase(const SourceName &name) {
   auto it{symbols_.find(name)};
   if (it != end()) {
     symbols_.erase(it);
     return 1;
   } else {
     return 0;
   }
 }
-Symbol *Scope::FindSymbol(const SourceName &name) const {
+
+Symbol *Scope::FindLocalSymbol(const SourceName &name) const {
   auto it{find(name)};
   if (it != end()) {
     return &*it->second;
+  } else {
+    return nullptr;
+  }
+}
+
+Symbol *Scope::FindSymbol(const SourceName &name) const {
+  if (Symbol * local{FindLocalSymbol(name)}) {
+    return local;
   } else if (CanImport(name)) {
     return parent_.FindSymbol(name);
   } else {
     return nullptr;
   }
 }
 
 Symbol *Scope::FindComponent(SourceName name) const {

flang/test/Semantics/equivalence01.f90

subroutine s16
 
   interface
     subroutine interfaceSub (dupName)
       integer dupName
     end subroutine interfaceSub
   end interface
 
 end subroutine s16
+
+module m17
+  real :: dupName
+contains
+  real function f17a()
+    implicit none
+    real :: y
+    !ERROR: No explicit type declared for 'dupname'
+    equivalence (dupName, y) 
+  end function f17a
+  real function f17b()
+    real :: y
+    ! The following implicitly declares an object called "dupName" local to 
+    ! the function f17b().  OK since there's no "implicit none
+    equivalence (dupName, y) 
+  end function f17b
+end module m17