[flang] Don't propagate PRIVATE into submodule module files

[klausler]

Summary

Module files for submodules should not contain PRIVATE attributes,
since everything in them is local to the parent module and
accessible to all descendant submodules.

flang/lib/Semantics/mod-file.h

private:
   // Tracks nested DEC structures and fields of that type
   UnorderedSymbolSet emittedDECStructures_, emittedDECFields_;
 
   llvm::raw_string_ostream uses_{usesBuf_};
   llvm::raw_string_ostream useExtraAttrs_{
       useExtraAttrsBuf_}; // attrs added to used entity
   llvm::raw_string_ostream decls_{declsBuf_};
   llvm::raw_string_ostream contains_{containsBuf_};
+  bool isSubmodule_{false};
 
   void WriteAll(const Scope &);
   void WriteOne(const Scope &);
   void Write(const Symbol &);
   std::string GetAsString(const Symbol &);
   void PutSymbols(const Scope &);
   // Returns true if a derived type with bindings and "contains" was emitted
   bool PutComponents(const Symbol &);
   void PutSymbol(llvm::raw_ostream &, const Symbol &);
   void PutEntity(llvm::raw_ostream &, const Symbol &);
   void PutEntity(
       llvm::raw_ostream &, const Symbol &, std::function<void()>, Attrs);
   void PutObjectEntity(llvm::raw_ostream &, const Symbol &);
   void PutProcEntity(llvm::raw_ostream &, const Symbol &);
   void PutDerivedType(const Symbol &, const Scope * = nullptr);
   void PutDECStructure(const Symbol &, const Scope * = nullptr);
   void PutTypeParam(llvm::raw_ostream &, const Symbol &);
   void PutSubprogram(const Symbol &);
   void PutGeneric(const Symbol &);
   void PutUse(const Symbol &);
   void PutUseExtraAttr(Attr, const Symbol &, const Symbol &);
+  llvm::raw_ostream &PutAttrs(llvm::raw_ostream &, Attrs,
+      const std::string * = nullptr, std::string before = ","s,
+      std::string after = ""s) const;
 };
 
 class ModFileReader {
 public:
   // directories specifies where to search for module files
   ModFileReader(SemanticsContext &context) : context_{context} {}
   // Find and read the module file for a module or submodule.
   // If ancestor is specified, look for a submodule of that module.

flang/lib/Semantics/mod-file.cpp

 static void PutPassName(llvm::raw_ostream &, const std::optional<SourceName> &);
 static void PutInit(llvm::raw_ostream &, const Symbol &, const MaybeExpr &,
     const parser::Expr *);
 static void PutInit(llvm::raw_ostream &, const MaybeIntExpr &);
 static void PutBound(llvm::raw_ostream &, const Bound &);
 static void PutShapeSpec(llvm::raw_ostream &, const ShapeSpec &);
 static void PutShape(
     llvm::raw_ostream &, const ArraySpec &, char open, char close);
-llvm::raw_ostream &PutAttrs(llvm::raw_ostream &, Attrs,
-    const std::string * = nullptr, std::string before = ","s,
-    std::string after = ""s);
 
 static llvm::raw_ostream &PutAttr(llvm::raw_ostream &, Attr);
 static llvm::raw_ostream &PutType(llvm::raw_ostream &, const DeclTypeSpec &);
 static llvm::raw_ostream &PutLower(llvm::raw_ostream &, std::string_view);
 static std::error_code WriteFile(
     const std::string &, const std::string &, bool = true);
 static bool FileContentsMatch(
     const std::string &, const std::string &, const std::string &);
static std::string ModFileName(const SourceName &name,
     const std::string &ancestorName, const std::string &suffix) {
   std::string result{name.ToString() + suffix};
   return ancestorName.empty() ? result : ancestorName + '-' + result;
 }
 
 // Write the module file for symbol, which must be a module or submodule.
 void ModFileWriter::Write(const Symbol &symbol) {
   auto *ancestor{symbol.get<ModuleDetails>().ancestor()};
+  isSubmodule_ = ancestor != nullptr;
   auto ancestorName{ancestor ? ancestor->GetName().value().ToString() : ""s};
   auto path{context_.moduleDirectory() + '/' +
       ModFileName(symbol.name(), ancestorName, context_.moduleFileSuffix())};
   PutSymbols(DEREF(symbol.scope()));
   if (std::error_code error{
           WriteFile(path, GetAsString(symbol), context_.debugModuleWriter())}) {
     context_.Say(
         symbol.name(), "Error writing %s: %s"_err_en_US, path, error.message());
common::visit(
           [&](const NamelistDetails &x) {
             decls_ << "namelist/" << symbol.name();
             char sep{'/'};
             for (const Symbol &object : x.objects()) {
               decls_ << sep << object.name();
               sep = ',';
             }
             decls_ << '\n';
+            if (!isSubmodule_ && symbol.attrs().test(Attr::PRIVATE)) {
+              decls_ << "private::" << symbol.name() << '\n';
+            }
           },
           [&](const CommonBlockDetails &x) {
             decls_ << "common/" << symbol.name();
             char sep = '/';
             for (const auto &object : x.objects()) {
               decls_ << sep << object->name();
               sep = ',';
             }
void ModFileWriter::PutGeneric(const Symbol &symbol) {
   auto &details{symbol.get<GenericDetails>()};
   PutGenericName(decls_ << "interface ", symbol) << '\n';
   for (const Symbol &specific : details.specificProcs()) {
     if (specific.owner() == genericOwner) {
       decls_ << "procedure::" << specific.name() << '\n';
     }
   }
   decls_ << "end interface\n";
-  if (symbol.attrs().test(Attr::PRIVATE)) {
+  if (!isSubmodule_ && symbol.attrs().test(Attr::PRIVATE)) {
     PutGenericName(decls_ << "private::", symbol) << '\n';
   }
 }
 
 void ModFileWriter::PutUse(const Symbol &symbol) {
   auto &details{symbol.get<UseDetails>()};
   auto &use{details.symbol()};
   const Symbol &module{GetUsedModule(details)};
   if (use.owner().parent().IsIntrinsicModules()) {
     uses_ << "use,intrinsic::";
   } else {
     uses_ << "use ";
   }
   uses_ << module.name() << ",only:";
   PutGenericName(uses_, symbol);
   // Can have intrinsic op with different local-name and use-name
   // (e.g. `operator(<)` and `operator(.lt.)`) but rename is not allowed
   if (!IsIntrinsicOp(symbol) && use.name() != symbol.name()) {
     PutGenericName(uses_ << "=>", use);
   }
   uses_ << '\n';
   PutUseExtraAttr(Attr::VOLATILE, symbol, use);
   PutUseExtraAttr(Attr::ASYNCHRONOUS, symbol, use);
-  if (symbol.attrs().test(Attr::PRIVATE)) {
+  if (!isSubmodule_ && symbol.attrs().test(Attr::PRIVATE)) {
     PutGenericName(useExtraAttrs_ << "private::", symbol) << '\n';
   }
 }
 
 // We have "USE local => use" in this module. If attr was added locally
 // (i.e. on local but not on use), also write it out in the mod file.
 void ModFileWriter::PutUseExtraAttr(
     Attr attr, const Symbol &local, const Symbol &use) {
void ModFileWriter::PutObjectEntity(
   PutShape(os, details.coshape(), '[', ']');
   PutInit(os, symbol, details.init(), details.unanalyzedPDTComponentInit());
   os << '\n';
 }
 
 void ModFileWriter::PutProcEntity(llvm::raw_ostream &os, const Symbol &symbol) {
   if (symbol.attrs().test(Attr::INTRINSIC)) {
     os << "intrinsic::" << symbol.name() << '\n';
-    if (symbol.attrs().test(Attr::PRIVATE)) {
+    if (!isSubmodule_ && symbol.attrs().test(Attr::PRIVATE)) {
       os << "private::" << symbol.name() << '\n';
     }
     return;
   }
   const auto &details{symbol.get<ProcEntityDetails>()};
   const ProcInterface &interface { details.interface() };
   Attrs attrs{symbol.attrs()};
   if (details.passName()) {
if (symbol.owner().kind() == Scope::Kind::DerivedType &&
     os << "::%FILL";
   } else {
     os << "::" << symbol.name();
   }
 }
 
 // Put out each attribute to os, surrounded by `before` and `after` and
 // mapped to lower case.
-llvm::raw_ostream &PutAttrs(llvm::raw_ostream &os, Attrs attrs,
-    const std::string *bindName, std::string before, std::string after) {
+llvm::raw_ostream &ModFileWriter::PutAttrs(llvm::raw_ostream &os, Attrs attrs,
+    const std::string *bindName, std::string before, std::string after) const {
   attrs.set(Attr::PUBLIC, false); // no need to write PUBLIC
   attrs.set(Attr::EXTERNAL, false); // no need to write EXTERNAL
+  if (isSubmodule_) {
+    attrs.set(Attr::PRIVATE, false);
+  }
   if (bindName) {
     os << before << "bind(c, name=\"" << *bindName << "\")" << after;
     attrs.set(Attr::BIND_C, false);
   }
   for (std::size_t i{0}; i < Attr_enumSize; ++i) {
     Attr attr{static_cast<Attr>(i)};
     if (attrs.test(attr)) {
       PutAttr(os << before, attr) << after;