[flang] Allow a generic-spec on a PUBLIC/PRIVATE statement to declare a generic

[klausler]

Summary

A generic-spec can appear on a module accessibility control statement
even if it has not been declared as a generic interface, because there's
nothing else that it could be.

While here, simplify the parse tree and parser for AccessId, since
one of its alternatives is ambiguous with the other.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/include/flang/Parser/parse-tree.h

 // R801 type-declaration-stmt ->
 //        declaration-type-spec [[, attr-spec]... ::] entity-decl-list
 struct TypeDeclarationStmt {
   TUPLE_CLASS_BOILERPLATE(TypeDeclarationStmt);
   std::tuple<DeclarationTypeSpec, std::list<AttrSpec>, std::list<EntityDecl>> t;
 };
 
 // R828 access-id -> access-name | generic-spec
-struct AccessId {
-  UNION_CLASS_BOILERPLATE(AccessId);
-  std::variant<Name, common::Indirection<GenericSpec>> u;
-};
+// "access-name" is ambiguous with "generic-spec", so that's what's parsed
+WRAPPER_CLASS(AccessId, common::Indirection<GenericSpec>);
 
 // R827 access-stmt -> access-spec [[::] access-id-list]
 struct AccessStmt {
   TUPLE_CLASS_BOILERPLATE(AccessStmt);
   std::tuple<AccessSpec, std::list<AccessId>> t;
 };
 
 // R830 allocatable-decl ->

flang/lib/Parser/Fortran-parsers.cpp

 
 // R827 access-stmt -> access-spec [[::] access-id-list]
 TYPE_PARSER(construct<AccessStmt>(accessSpec,
     defaulted(maybe("::"_tok) >>
         nonemptyList("expected names and generic specifications"_err_en_US,
             Parser<AccessId>{}))))
 
 // R828 access-id -> access-name | generic-spec
-TYPE_PARSER(construct<AccessId>(indirect(genericSpec)) ||
-    construct<AccessId>(name)) // initially ambiguous with genericSpec
+// "access-name" is ambiguous with "generic-spec"
+TYPE_PARSER(construct<AccessId>(indirect(genericSpec)))
 
 // R829 allocatable-stmt -> ALLOCATABLE [::] allocatable-decl-list
 TYPE_PARSER(construct<AllocatableStmt>("ALLOCATABLE" >> maybe("::"_tok) >>
     nonemptyList(
         "expected object declarations"_err_en_US, Parser<ObjectDecl>{})))
 
 // R830 allocatable-decl ->
 //        object-name [( array-spec )] [lbracket coarray-spec rbracket]

flang/lib/Semantics/resolve-names.cpp

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;
   } else {
     for (const auto &accessId : accessIds) {
-      common::visit(
-          common::visitors{
-              [=](const parser::Name &y) {
-                Resolve(y, SetAccess(y.source, accessAttr));
-              },
-              [=](const Indirection<parser::GenericSpec> &y) {
-                auto info{GenericSpecInfo{y.value()}};
-                const auto &symbolName{info.symbolName()};
-                if (auto *symbol{FindInScope(symbolName)}) {
-                  info.Resolve(&SetAccess(symbolName, accessAttr, symbol));
-                } else if (info.kind().IsName()) {
-                  info.Resolve(&SetAccess(symbolName, accessAttr));
-                } else {
-                  Say(symbolName, "Generic spec '%s' not found"_err_en_US);
-                }
-              },
-          },
-          accessId.u);
+      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));
     }
   }
   return false;
 }
 
 // Set the access specification for this symbol.
 Symbol &ModuleVisitor::SetAccess(
     const SourceName &name, Attr attr, Symbol *symbol) {

flang/test/Semantics/modfile51.f90

+! RUN: %python %S/test_modfile.py %s %flang_fc1
+! Allow a generic spec that is not a name to be declared on an
+! accessibility control statement
+module m
+  public :: assignment(=)
+  public :: read(unformatted)
+  public :: operator(.eq.)
+  public :: operator(.smooth.)
+end module
+
+!Expect: m.mod
+!module m
+!interface assignment(=)
+!end interface
+!interface read(unformatted)
+!end interface
+!interface operator(.eq.)
+!end interface
+!interface operator(.smooth.)
+!end interface
+!end