[flang] Allow ENTRY function result symbol usage before the ENTRY

[klausler]

Summary

In a function, ENTRY E without an explicit RESULT() creates a
function result entity also named E that is storage associated with
the enclosing function's result. f18 was emitting an incorrect error
message if that function result E was referenced without any
declaration prior to its ENTRY statement when it should have been
implicitly declared instead.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Semantics/resolve-names.cpp

public:
   void Post(const parser::InterfaceBody::Subroutine &);
   bool Pre(const parser::InterfaceBody::Function &);
   void Post(const parser::InterfaceBody::Function &);
   bool Pre(const parser::Suffix &);
   bool Pre(const parser::PrefixSpec &);
 
   bool BeginSubprogram(const parser::Name &, Symbol::Flag,
       bool hasModulePrefix = false,
-      const parser::LanguageBindingSpec * = nullptr);
+      const parser::LanguageBindingSpec * = nullptr,
+      const ProgramTree::EntryStmtList * = nullptr);
   bool BeginMpSubprogram(const parser::Name &);
   void PushBlockDataScope(const parser::Name &);
   void EndSubprogram();
 
 protected:
   // Set when we see a stmt function that is really an array element assignment
   bool badStmtFuncFound_{false};
 
if (resultName->source == name.source) {
       // ignore RESULT() hereafter when it's the same name as the ENTRY
       resultName = nullptr;
     }
   }
   SubprogramDetails entryDetails;
   entryDetails.set_entryScope(inclusiveScope);
   if (inFunction) {
     // Create the entity to hold the function result, if necessary.
-    Symbol *resultSymbol{nullptr};
     auto &effectiveResultName{*(resultName ? resultName : &name)};
-    resultSymbol = FindInScope(currScope(), effectiveResultName);
+    Symbol *resultSymbol{FindInScope(currScope(), effectiveResultName)};
     if (resultSymbol) { // C1574
       common::visit(
-          common::visitors{[](EntityDetails &x) { x.set_funcResult(true); },
+          common::visitors{[resultSymbol](UnknownDetails &) {
+                             EntityDetails entity;
+                             entity.set_funcResult(true);
+                             resultSymbol->set_details(std::move(entity));
+                           },
+              [](EntityDetails &x) { x.set_funcResult(true); },
               [](ObjectEntityDetails &x) { x.set_funcResult(true); },
               [](ProcEntityDetails &x) { x.set_funcResult(true); },
               [&](const auto &) {
                 Say2(effectiveResultName.source,
                     "'%s' was previously declared as an item that may not be used as a function result"_err_en_US,
                     resultSymbol->name(), "Previous declaration of '%s'"_en_US);
                 context().SetError(*resultSymbol);
               }},
           resultSymbol->details());
+      // The Function flag will have been set if the ENTRY's symbol was created
+      // as a placeholder in BeginSubprogram.  This prevents misuse of the ENTRY
+      // as a subroutine.  Clear it now because it's inappropriate for a
+      // function result.
+      resultSymbol->set(Symbol::Flag::Function, false);
     } else if (!inSpecificationPart_) {
       ObjectEntityDetails entity;
       entity.set_funcResult(true);
       resultSymbol = &MakeSymbol(effectiveResultName, std::move(entity));
       ApplyImplicitRules(*resultSymbol);
     } else {
       EntityDetails entity;
       entity.set_funcResult(true);
if (symbol->owner() == currScope() && symbol->scope()) {
     }
   }
   return true;
 }
 
 // A subprogram or interface declared with SUBROUTINE or FUNCTION
 bool SubprogramVisitor::BeginSubprogram(const parser::Name &name,
     Symbol::Flag subpFlag, bool hasModulePrefix,
-    const parser::LanguageBindingSpec *bindingSpec) {
+    const parser::LanguageBindingSpec *bindingSpec,
+    const ProgramTree::EntryStmtList *entryStmts) {
   if (hasModulePrefix && currScope().IsGlobal()) { // C1547
     Say(name,
         "'%s' is a MODULE procedure which must be declared within a "
         "MODULE or SUBMODULE"_err_en_US);
     return false;
   }
   Symbol *moduleInterface{nullptr};
   if (hasModulePrefix && !inInterfaceBlock()) {
if (moduleInterface) {
     if (moduleInterface->attrs().test(Attr::PRIVATE)) {
       newSymbol.attrs().set(Attr::PRIVATE);
     } else if (moduleInterface->attrs().test(Attr::PUBLIC)) {
       newSymbol.attrs().set(Attr::PUBLIC);
     }
   }
   if (IsFunction(currScope())) {
     funcResultStack().Push();
+    if (entryStmts) {
+      // It's possible to refer to the function result variable of an ENTRY
+      // statement that lacks an explicit RESULT in code that appears before the
+      // ENTRY. Create a placeholder symbol now for that case so that the name
+      // doesn't resolve instead to the ENTRY's symbol in the scope around the
+      // function.
+      for (const auto &ref : *entryStmts) {
+        const auto &suffix{std::get<std::optional<parser::Suffix>>(ref->t)};
+        if (!(suffix && suffix->resultName)) {
+          Symbol &symbol{MakeSymbol(std::get<parser::Name>(ref->t).source,
+              Attrs{}, UnknownDetails{})};
+          symbol.set(Symbol::Flag::Function);
+        }
+      }
+    }
   }
   return true;
 }
 
 void SubprogramVisitor::EndSubprogram() {
   if (IsFunction(currScope())) {
     funcResultStack().Pop();
   }
switch (node.GetKind()) {
     SWITCH_COVERS_ALL_CASES
   case ProgramTree::Kind::Program:
     PushScope(Scope::Kind::MainProgram,
         &MakeSymbol(node.name(), MainProgramDetails{}));
     return true;
   case ProgramTree::Kind::Function:
   case ProgramTree::Kind::Subroutine:
     return BeginSubprogram(node.name(), node.GetSubpFlag(),
-        node.HasModulePrefix(), node.bindingSpec());
+        node.HasModulePrefix(), node.bindingSpec(), &node.entryStmts());
   case ProgramTree::Kind::MpSubprogram:
     return BeginMpSubprogram(node.name());
   case ProgramTree::Kind::Module:
     BeginModule(node.name(), false);
     return true;
   case ProgramTree::Kind::Submodule:
     return BeginSubmodule(node.name(), node.GetParentId());
   case ProgramTree::Kind::BlockData:

flang/test/Semantics/entry01.f90

function ifunc()
   !ERROR: Result of ENTRY is not compatible with result of containing function
   entry ibadt2() result(weird6)
   !ERROR: Result of ENTRY is not compatible with result of containing function
   entry ibadt3() result(iarr)
   !ERROR: Result of ENTRY is not compatible with result of containing function
   entry ibadt4() result(alloc)
   !ERROR: Result of ENTRY is not compatible with result of containing function
   entry ibadt5() result(ptr)
+  !ERROR: Cannot call function 'isubr' like a subroutine
   call isubr
-  !ERROR: 'isubr' was previously called as a subroutine
   entry isubr()
   continue ! force transition to execution part
   entry implicit()
   implicit = 666 ! ok, just ensure that it works
 end function
 
 function chfunc() result(chr)
   character(len=1) :: chr
function inone
   implicit none
   integer :: inone
   !ERROR: No explicit type declared for 'implicitbad1'
   entry implicitbad1
   inone = 0 ! force transition to execution part
   !ERROR: No explicit type declared for 'implicitbad2'
   entry implicitbad2
 end
+
+module m5
+ contains
+  real function setBefore
+    ent = 1.0
+    entry ent
+  end function
+end module