[flang] Fix implicit declarations in statement functions

[tskeith]

Summary

If a symbol (that is not a dummy argument) is implicitly declared inside
a statement function, don't create it in the statement function's scope.
Instead, treat statement functions like blocks when finding the inclusive
scope and create the symbol there.

Add a new flag, StmtFunction, to symbols that represent statement functions.

[sscalpone]

Looks good, Tim. The fcvs tests fm311 passes with this change.

flang/include/flang/Semantics/scope.h

const Scope &parent() const {
     CHECK(&parent_ != this);
     return parent_;
   }
   Kind kind() const { return kind_; }
   bool IsGlobal() const { return kind_ == Kind::Global; }
   bool IsModule() const; // only module, not submodule
   bool IsSubmodule() const;
   bool IsDerivedType() const { return kind_ == Kind::DerivedType; }
+  bool IsStmtFunction() const;
   bool IsParameterizedDerivedType() const;
   Symbol *symbol() { return symbol_; }
   const Symbol *symbol() const { return symbol_; }
 
   inline const Symbol *GetSymbol() const;
   const Scope *GetDerivedTypeParent() const;
   const Scope &GetDerivedTypeBase() const;
   std::optional<SourceName> GetName() const;

flang/include/flang/Semantics/symbol.h

 std::string DetailsToString(const Details &);
 
 class Symbol {
 public:
   ENUM_CLASS(Flag,
       Error, // an error has been reported on this symbol
       Function, // symbol is a function
       Subroutine, // symbol is a subroutine
+      StmtFunction, // symbol is a statement function (Function is set too)
       Implicit, // symbol is implicitly typed
       ModFile, // symbol came from .mod file
       ParentComp, // symbol is the "parent component" of an extended type
       CrayPointer, CrayPointee,
       LocalityLocal, // named in LOCAL locality-spec
       LocalityLocalInit, // named in LOCAL_INIT locality-spec
       LocalityShared, // named in SHARED locality-spec
       InDataStmt, // initialized in a DATA statement

flang/lib/Semantics/resolve-names.cpp

 void ScopeHandler::Say2(const parser::Name &name, MessageFixedText &&msg1,
     Symbol &symbol, MessageFixedText &&msg2) {
   Say2(name.source, std::move(msg1), symbol.name(), std::move(msg2));
   context().SetError(symbol, msg1.isFatal());
 }
 
 Scope &ScopeHandler::InclusiveScope() {
   for (auto *scope{&currScope()};; scope = &scope->parent()) {
-    if (scope->kind() != Scope::Kind::Block && !scope->IsDerivedType()) {
+    if (scope->kind() != Scope::Kind::Block && !scope->IsDerivedType() &&
+        !scope->IsStmtFunction()) {
       return *scope;
     }
   }
   DIE("inclusive scope not found");
 }
 
 Scope &ScopeHandler::NonDerivedTypeScope() {
   return currScope_->IsDerivedType() ? currScope_->parent() : *currScope_;
if (auto *symbol{FindSymbol(name)}) {
     resultType = details->type();
     symbol->details() = UnknownDetails{}; // will be replaced below
   }
   if (badStmtFuncFound_) {
     Say(name, "'%s' has not been declared as an array"_err_en_US);
     return true;
   }
   auto &symbol{PushSubprogramScope(name, Symbol::Flag::Function)};
+  symbol.set(Symbol::Flag::StmtFunction);
   EraseSymbol(symbol); // removes symbol added by PushSubprogramScope
   auto &details{symbol.get<SubprogramDetails>()};
   for (const auto &dummyName : std::get<std::list<parser::Name>>(x.t)) {
     ObjectEntityDetails dummyDetails{true};
     if (auto *dummySymbol{FindInScope(currScope().parent(), dummyName)}) {
       if (auto *d{dummySymbol->detailsIf<EntityDetails>()}) {
         if (d->type()) {
           dummyDetails.set_type(*d->type());

flang/lib/Semantics/scope.cpp

llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Scope &scope) {
   }
   for (const auto &pair : scope.commonBlocks_) {
     const Symbol &symbol{*pair.second};
     os << "  " << symbol << '\n';
   }
   return os;
 }
 
+bool Scope::IsStmtFunction() const {
+  return symbol_ && symbol_->test(Symbol::Flag::StmtFunction);
+}
+
 bool Scope::IsParameterizedDerivedType() const {
   if (!IsDerivedType()) {
     return false;
   }
   if (const Scope * parent{GetDerivedTypeParent()}) {
     if (parent->IsParameterizedDerivedType()) {
       return true;
     }

flang/test/Semantics/symbol16.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
 ! Statement functions
 
 !DEF: /p1 MainProgram
 program p1
- !DEF: /p1/f (Function) Subprogram INTEGER(4)
+ !DEF: /p1/f (Function, StmtFunction) Subprogram INTEGER(4)
  !DEF: /p1/i ObjectEntity INTEGER(4)
  !DEF: /p1/j ObjectEntity INTEGER(4)
  integer f, i, j
  !REF: /p1/f
  !REF: /p1/i
  !DEF: /p1/f/i ObjectEntity INTEGER(4)
  f(i) = i + 1
  !REF: /p1/j
  !REF: /p1/f
  j = f(2)
 end program
+
+!DEF: /p2 MainProgram
+program p2
+ !DEF: /p2/f (Function, StmtFunction) Subprogram REAL(4)
+ !DEF: /p2/f/x (Implicit) ObjectEntity REAL(4)
+ !DEF: /p2/y (Implicit) ObjectEntity REAL(4)
+ f(x) = y
+ !REF: /p2/y
+ y = 1.0
+end program