[flang] Allow implicit declaration of DATA objects in inner procedures

[klausler]

Summary

DATA statements in inner procedures were not treating undeclared objects
as implicitly declared variables if the DATA statement appeared in a
specification part; they were treated as host-associated symbols instead.
This was incorrect. Fix DATA statement name resolution to always treat
DATA as if it had appeared in the executable part.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Semantics/resolve-names.cpp

protected:
   const DeclTypeSpec &MakeNumericType(
       TypeCategory, const std::optional<parser::KindSelector> &);
   const DeclTypeSpec &MakeLogicalType(
       const std::optional<parser::KindSelector> &);
   void NotePossibleBadForwardRef(const parser::Name &);
   std::optional<SourceName> HadForwardRef(const Symbol &) const;
   bool CheckPossibleBadForwardRef(const Symbol &);
 
-  bool inExecutionPart_{false};
   bool inSpecificationPart_{false};
   bool inEquivalenceStmt_{false};
 
   // Some information is collected from a specification part for deferred
   // processing in DeclarationPartVisitor functions (e.g., CheckSaveStmts())
   // that are called by ResolveNamesVisitor::FinishSpecificationPart().  Since
   // specification parts can nest (e.g., INTERFACE bodies), the collected
   // information that is not contained in the scope needs to be packaged
if (resultSymbol) { // C1574
               [](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());
-    } else if (inExecutionPart_) {
+    } else if (!inSpecificationPart_) {
       ObjectEntityDetails entity;
       entity.set_funcResult(true);
       resultSymbol = &MakeSymbol(effectiveResultName, std::move(entity));
       ApplyImplicitRules(*resultSymbol);
     } else {
       EntityDetails entity;
       entity.set_funcResult(true);
       resultSymbol = &MakeSymbol(effectiveResultName, std::move(entity));
if (const auto *dummyName{std::get_if<parser::Name>(&dummyArg.u)}) {
                 [&](const auto &) {
                   Say2(dummyName->source,
                       "ENTRY dummy argument '%s' is previously declared as an item that may not be used as a dummy argument"_err_en_US,
                       dummy->name(), "Previous declaration of '%s'"_en_US);
                 }},
             dummy->details());
       } else {
         dummy = &MakeSymbol(*dummyName, EntityDetails{true});
-        if (inExecutionPart_) {
+        if (!inSpecificationPart_) {
           ApplyImplicitRules(*dummy);
         }
       }
       entryDetails.add_dummyArg(*dummy);
     } else {
       if (inFunction) { // C1573
         Say(name,
             "ENTRY in a function may not have an alternate return dummy argument"_err_en_US);
common::visit(
           },
           [&](const Indirection<parser::DataImpliedDo> &y) { Walk(y.value()); },
       },
       x.u);
   return false;
 }
 
 bool ConstructVisitor::Pre(const parser::DataStmtObject &x) {
+  // Subtle: DATA statements may appear in both the specification and
+  // execution parts, but should be treated as if in the execution part
+  // for purposes of implicit variable declaration vs. host association.
+  // When a name first appears as an object in a DATA statement, it should
+  // be implicitly declared locally as if it had been assigned.
+  auto flagRestorer{common::ScopedSet(inSpecificationPart_, false)};
   common::visit(common::visitors{
                     [&](const Indirection<parser::Variable> &y) {
                       Walk(y.value());
                       const parser::Name &first{
                           parser::GetFirstName(y.value())};
                       if (first.symbol) {
                         first.symbol->set(Symbol::Flag::InDataStmt);
                       }

 // is implicitly typed. Because specification parts are processed before
 // execution parts, this may be the first time we see the symbol. It can't be a
 // local in the current scope (because it's in a specification expression) so
 // either it is implicitly declared in the host procedure or it is an error.
 // We create a symbol in the host assuming it is the former; if that proves to
 // be wrong we report an error later in CheckDeclarations().
 bool DeclarationVisitor::CheckForHostAssociatedImplicit(
     const parser::Name &name) {
-  if (inExecutionPart_) {
+  if (!inSpecificationPart_) {
     return false;
   }
   if (name.symbol) {
     ApplyImplicitRules(*name.symbol, true);
   }
   Symbol *hostSymbol;
   Scope *host{GetHostProcedure()};
   if (!host || isImplicitNoneType(*host)) {
if (std::holds_alternative<common::Indirection<parser::CompilerDirective>>(
           x.u)) {
     // TODO: global directives
     return true;
   }
   auto root{ProgramTree::Build(x)};
   SetScope(topScope_);
   ResolveSpecificationParts(root);
   FinishSpecificationParts(root);
-  inExecutionPart_ = true;
   ResolveExecutionParts(root);
-  inExecutionPart_ = false;
   ResolveAccParts(context(), x);
   ResolveOmpParts(context(), x);
   return false;
 }
 
 // References to procedures need to record that their symbols are known
 // to be procedures, so that they don't get converted to objects by default.
 class ExecutionPartSkimmer {

flang/test/Semantics/data16.f90

+! RUN: %python %S/test_errors.py %s %flang_fc1
+! Ensure that implicit declarations work in DATA statements
+! appearing in specification parts of inner procedures; they
+! should not elicit diagnostics about initialization of host
+! associated objects.
+program main
+ contains
+  subroutine subr
+    data foo/6.66/ ! implicit declaration of "foo": ok
+    !ERROR: Implicitly typed local entity 'n' not allowed in specification expression
+    real a(n)
+    !ERROR: Host-associated object 'n' must not be initialized in a DATA statement
+    data n/123/
+  end subroutine
+end program