[flang] Apply default module accessibility rules a second time (bug#62598)

[klausler]

Summary

Apply the default PUBLIC/PRIVATE accessibility of a module to its symbols
a second time after it is known that all symbols, including implicitly typed
names from NAMELIST groups and specification expressions in module subprograms,
have been created in its scope.

Fixes https://github.com/llvm/llvm-project/issues/62598.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/docs/Extensions.md

program demo
   print *, k, " should be 3"
 end
 
 ```
 
   Other Fortran compilers disagree in their interpretations of this example;
   some seem to treat the references to `m` as if they were host associations
   to an implicitly typed variable (and print `3`), while others seem to
-  treat them as references to implicitly typed local variabless, and
+  treat them as references to implicitly typed local variables, and
   load uninitialized values.
 
   In f18, we chose to emit an error message for this case since the standard
   is unclear, the usage is not portable, and the issue can be easily resolved
   by adding a declaration.
 
 * In subclause 7.5.6.2 of Fortran 2018 the standard defines a partial ordering
   of the final subroutine calls for finalizable objects, their non-parent

flang/include/flang/Semantics/symbol.h

 class ModuleDetails {
 public:
   ModuleDetails(bool isSubmodule = false) : isSubmodule_{isSubmodule} {}
   bool isSubmodule() const { return isSubmodule_; }
   const Scope *scope() const { return scope_; }
   const Scope *ancestor() const; // for submodule; nullptr for module
   const Scope *parent() const; // for submodule; nullptr for module
   void set_scope(const Scope *);
+  bool isDefaultPrivate() const { return isDefaultPrivate_; }
+  void set_isDefaultPrivate(bool yes = true) { isDefaultPrivate_ = yes; }
 
 private:
   bool isSubmodule_;
+  bool isDefaultPrivate_{false};
   const Scope *scope_{nullptr};
 };
 
 class MainProgramDetails {
 public:
 private:
 };
 

flang/lib/Semantics/resolve-names.cpp

public:
   void ClearUseRenames() { useRenames_.clear(); }
   void ClearUseOnly() { useOnly_.clear(); }
   void ClearModuleUses() {
     intrinsicUses_.clear();
     nonIntrinsicUses_.clear();
   }
 
 private:
-  // The default access spec for this module.
-  Attr defaultAccess_{Attr::PUBLIC};
   // The location of the last AccessStmt without access-ids, if any.
   std::optional<SourceName> prevAccessStmt_;
   // The scope of the module during a UseStmt
   Scope *useModuleScope_{nullptr};
   // Names that have appeared in a rename clause of a USE statement
   std::set<std::pair<SourceName, Scope *>> useRenames_;
   // Names that have appeared in an ONLY clause of a USE statement
   std::set<std::pair<SourceName, Scope *>> useOnly_;
bool ModuleVisitor::BeginSubmodule(
   return true;
 }
 
 void ModuleVisitor::BeginModule(const parser::Name &name, bool isSubmodule) {
   auto &symbol{MakeSymbol(name, ModuleDetails{isSubmodule})};
   auto &details{symbol.get<ModuleDetails>()};
   PushScope(Scope::Kind::Module, &symbol);
   details.set_scope(&currScope());
-  defaultAccess_ = Attr::PUBLIC;
   prevAccessStmt_ = std::nullopt;
 }
 
 // Find a module or submodule by name and return its scope.
 // If ancestor is present, look for a submodule of that ancestor module.
 // May have to read a .mod file to find it.
 // If an error occurs, report it and return nullptr.
 Scope *ModuleVisitor::FindModule(const parser::Name &name,
     std::optional<bool> isIntrinsic, Scope *ancestor) {
   ModFileReader reader{context()};
   Scope *scope{reader.Read(name.source, isIntrinsic, ancestor)};
   if (!scope) {
     return nullptr;
   }
   if (DoesScopeContain(scope, currScope())) { // 14.2.2(1)
     Say(name, "Module '%s' cannot USE itself"_err_en_US);
   }
   Resolve(name, scope->symbol());
   return scope;
 }
 
 void ModuleVisitor::ApplyDefaultAccess() {
+  const auto *moduleDetails{
+      DEREF(currScope().symbol()).detailsIf<ModuleDetails>()};
+  CHECK(moduleDetails);
   for (auto &pair : currScope()) {
-    Symbol &symbol = *pair.second;
+    Symbol &symbol{*pair.second};
     if (!symbol.attrs().HasAny({Attr::PUBLIC, Attr::PRIVATE})) {
-      SetImplicitAttr(symbol, defaultAccess_);
+      SetImplicitAttr(symbol,
+          DEREF(moduleDetails).isDefaultPrivate() ? Attr::PRIVATE
+                                                  : Attr::PUBLIC);
     }
   }
 }
 
 // InterfaceVistor implementation
 
 bool InterfaceVisitor::Pre(const parser::InterfaceStmt &x) {
   bool isAbstract{std::holds_alternative<parser::Abstract>(x.u)};
bool ModuleVisitor::Pre(const parser::AccessStmt &x) {
   }
   const auto &accessIds{std::get<std::list<parser::AccessId>>(x.t)};
   if (accessIds.empty()) {
     if (prevAccessStmt_) { // C869
       Say("The default accessibility of this module has already been declared"_err_en_US)
           .Attach(*prevAccessStmt_, "Previous declaration"_en_US);
     }
     prevAccessStmt_ = currStmtSource();
-    defaultAccess_ = accessAttr;
+    auto *moduleDetails{DEREF(currScope().symbol()).detailsIf<ModuleDetails>()};
+    DEREF(moduleDetails).set_isDefaultPrivate(accessAttr == Attr::PRIVATE);
   } else {
     for (const auto &accessId : accessIds) {
       GenericSpecInfo info{accessId.v.value()};
       auto *symbol{FindInScope(info.symbolName())};
       if (!symbol && !info.kind().IsName()) {
         symbol = &MakeSymbol(info.symbolName(), Attrs{}, GenericDetails{});
       }
       info.Resolve(&SetAccess(info.symbolName(), accessAttr, symbol));
void ResolveNamesVisitor::ResolveExecutionParts(const ProgramTree &node) {
   if (!node.scope()) {
     return; // error occurred creating scope
   }
   SetScope(*node.scope());
   if (const auto *exec{node.exec()}) {
     Walk(*exec);
   }
   FinishNamelists();
+  if (node.IsModule()) {
+    // A second final pass to catch new symbols added from implicitly
+    // typed names in NAMELIST groups or the specification parts of
+    // module subprograms.
+    ApplyDefaultAccess();
+  }
   PopScope(); // converts unclassified entities into objects
   for (const auto &child : node.children()) {
     ResolveExecutionParts(child);
   }
 }
 
 void ResolveNamesVisitor::Post(const parser::Program &) {
   // ensure that all temps were deallocated

flang/lib/Semantics/symbol.cpp

common::visit( //
                   auto parent{x.parent()->GetName().value()};
                   if (ancestor != parent) {
                     os << ':' << parent;
                   }
                 }
               }
               os << ")";
             }
+            if (x.isDefaultPrivate()) {
+              os << " isDefaultPrivate";
+            }
           },
           [&](const SubprogramNameDetails &x) {
             os << ' ' << EnumToString(x.kind());
           },
           [&](const UseDetails &x) {
             os << " from " << x.symbol().name() << " in "
                << GetUsedModule(x).name();
           },

flang/test/Semantics/symbol26.f90

+! RUN: %python %S/test_symbols.py %s %flang_fc1
+! Regression test for https://github.com/llvm/llvm-project/issues/62598
+! Ensure that implicitly typed names in module NAMELIST groups receive
+! the module's default accessibility attribute.
+!DEF: /m Module
+module m
+ !DEF: /m/a PUBLIC Namelist
+ !DEF: /m/j PUBLIC (Implicit, InNamelist) ObjectEntity INTEGER(4)
+ namelist/a/j
+end module m
+!DEF: /main MainProgram
+program main
+ !DEF: /main/j (Implicit) ObjectEntity INTEGER(4)
+ j = 1
+contains
+ !DEF: /main/inner (Subroutine) Subprogram
+ subroutine inner
+  !REF: /m
+  use :: m
+  !DEF: /main/inner/j (Implicit, InNamelist) Use INTEGER(4)
+  j = 2
+ end subroutine
+end program