[flang] Parse global compiler directives

[klausler]

Summary

Accept and represent "global" compiler directives that appear
before and between program units in a source file.

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

 // R502 program-unit ->
 //        main-program | external-subprogram | module | submodule | block-data
 // R503 external-subprogram -> function-subprogram | subroutine-subprogram
 struct ProgramUnit {
   UNION_CLASS_BOILERPLATE(ProgramUnit);
   std::variant<common::Indirection<MainProgram>,
       common::Indirection<FunctionSubprogram>,
       common::Indirection<SubroutineSubprogram>, common::Indirection<Module>,
-      common::Indirection<Submodule>, common::Indirection<BlockData>>
+      common::Indirection<Submodule>, common::Indirection<BlockData>,
+      common::Indirection<CompilerDirective>>
       u;
 };
 
 // R501 program -> program-unit [program-unit]...
 // This is the top-level production.
 WRAPPER_CLASS(Program, std::list<ProgramUnit>);
 
 // R603 name -> letter [alphanumeric-character]...

flang/lib/Parser/program-parsers.cpp

 #include "stmt-parser.h"
 #include "token-parsers.h"
 #include "type-parser-implementation.h"
 #include "flang/Parser/characters.h"
 #include "flang/Parser/parse-tree.h"
 
 namespace Fortran::parser {
 
-// R501 program -> program-unit [program-unit]...
-// This is the top-level production for the Fortran language.
-// F'2018 6.3.1 defines a program unit as a sequence of one or more lines,
-// implying that a line can't be part of two distinct program units.
-// Consequently, a program unit END statement should be the last statement
-// on its line.  We parse those END statements via unterminatedStatement()
-// and then skip over the end of the line here.
-TYPE_PARSER(construct<Program>(
-    extension<LanguageFeature::EmptySourceFile>(skipStuffBeforeStatement >>
-        !nextCh >> pure<std::list<ProgramUnit>>()) ||
-    some(StartNewSubprogram{} >> Parser<ProgramUnit>{} / skipMany(";"_tok) /
-            space / recovery(endOfLine, SkipPast<'\n'>{})) /
-        skipStuffBeforeStatement))
-
 // R502 program-unit ->
 //        main-program | external-subprogram | module | submodule | block-data
 // R503 external-subprogram -> function-subprogram | subroutine-subprogram
 // N.B. "module" must precede "external-subprogram" in this sequence of
 // alternatives to avoid ambiguity with the MODULE keyword prefix that
 // they recognize.  I.e., "modulesubroutinefoo" should start a module
 // "subroutinefoo", not a subroutine "foo" with the MODULE prefix.  The
 // ambiguity is exacerbated by the extension that accepts a function
 // statement without an otherwise empty list of dummy arguments.  That
 // MODULE prefix is disallowed by a constraint (C1547) in this context,
 // so the standard language is not ambiguous, but disabling its misrecognition
 // here would require context-sensitive keyword recognition or (or via)
 // variant parsers for several productions; giving the "module" production
 // priority here is a cleaner solution, though regrettably subtle.  Enforcing
 // C1547 is done in semantics.
-TYPE_PARSER(construct<ProgramUnit>(indirect(Parser<Module>{})) ||
+static constexpr auto programUnit{
+    construct<ProgramUnit>(indirect(Parser<Module>{})) ||
     construct<ProgramUnit>(indirect(functionSubprogram)) ||
     construct<ProgramUnit>(indirect(subroutineSubprogram)) ||
     construct<ProgramUnit>(indirect(Parser<Submodule>{})) ||
     construct<ProgramUnit>(indirect(Parser<BlockData>{})) ||
-    construct<ProgramUnit>(indirect(Parser<MainProgram>{})))
+    construct<ProgramUnit>(indirect(Parser<MainProgram>{}))};
+static constexpr auto normalProgramUnit{StartNewSubprogram{} >> programUnit /
+        skipMany(";"_tok) / space / recovery(endOfLine, SkipPast<'\n'>{})};
+static constexpr auto globalCompilerDirective{
+    construct<ProgramUnit>(indirect(compilerDirective))};
+
+// R501 program -> program-unit [program-unit]...
+// This is the top-level production for the Fortran language.
+// F'2018 6.3.1 defines a program unit as a sequence of one or more lines,
+// implying that a line can't be part of two distinct program units.
+// Consequently, a program unit END statement should be the last statement
+// on its line.  We parse those END statements via unterminatedStatement()
+// and then skip over the end of the line here.
+TYPE_PARSER(construct<Program>(
+    extension<LanguageFeature::EmptySourceFile>(skipStuffBeforeStatement >>
+        !nextCh >> pure<std::list<ProgramUnit>>()) ||
+    some(globalCompilerDirective || normalProgramUnit) /
+        skipStuffBeforeStatement))
 
 // R504 specification-part ->
 //         [use-stmt]... [import-stmt]... [implicit-part]
 //         [declaration-construct]...
 TYPE_CONTEXT_PARSER("specification part"_en_US,
     construct<SpecificationPart>(many(openaccDeclarativeConstruct),
         many(openmpDeclarativeConstruct), many(indirect(compilerDirective)),
         many(statement(indirect(Parser<UseStmt>{}))),

flang/lib/Semantics/program-tree.h

public:
   static ProgramTree Build(const parser::ProgramUnit &);
   static ProgramTree Build(const parser::MainProgram &);
   static ProgramTree Build(const parser::FunctionSubprogram &);
   static ProgramTree Build(const parser::SubroutineSubprogram &);
   static ProgramTree Build(const parser::SeparateModuleSubprogram &);
   static ProgramTree Build(const parser::Module &);
   static ProgramTree Build(const parser::Submodule &);
   static ProgramTree Build(const parser::BlockData &);
+  static ProgramTree Build(const parser::CompilerDirective &);
 
   ENUM_CLASS(Kind, // kind of node
       Program, Function, Subroutine, MpSubprogram, Module, Submodule, BlockData)
   using Stmt = std::variant< // the statement that introduces the program unit
       const parser::Statement<parser::ProgramStmt> *,
       const parser::Statement<parser::FunctionStmt> *,
       const parser::Statement<parser::SubroutineStmt> *,
       const parser::Statement<parser::MpSubprogramStmt> *,

flang/lib/Semantics/program-tree.cpp

ProgramTree ProgramTree::Build(const parser::BlockData &x) {
   const auto &stmt{std::get<parser::Statement<parser::BlockDataStmt>>(x.t)};
   const auto &end{std::get<parser::Statement<parser::EndBlockDataStmt>>(x.t)};
   static parser::Name emptyName;
   auto result{stmt.statement.v ? BuildSubprogramTree(*stmt.statement.v, x)
                                : BuildSubprogramTree(emptyName, x)};
   return result.set_stmt(stmt).set_endStmt(end);
 }
 
+ProgramTree ProgramTree::Build(const parser::CompilerDirective &) {
+  DIE("ProgramTree::Build() called for CompilerDirective");
+}
+
 const parser::ParentIdentifier &ProgramTree::GetParentId() const {
   const auto *stmt{
       std::get<const parser::Statement<parser::SubmoduleStmt> *>(stmt_)};
   return std::get<parser::ParentIdentifier>(stmt->statement.t);
 }
 
 bool ProgramTree::IsModule() const {
   auto kind{GetKind()};

flang/lib/Semantics/resolve-names.cpp

 }
 void ResolveNamesVisitor::Post(const parser::AssignedGotoStmt &x) {
   if (auto *name{ResolveName(std::get<parser::Name>(x.t))}) {
     ConvertToObjectEntity(DEREF(name->symbol));
   }
 }
 
 bool ResolveNamesVisitor::Pre(const parser::ProgramUnit &x) {
+  if (std::holds_alternative<common::Indirection<parser::CompilerDirective>>(
+          x.u)) {
+    // TODO: global directives
+    return true;
+  }
   auto root{ProgramTree::Build(x)};
   SetScope(context().globalScope());
   ResolveSpecificationParts(root);
   FinishSpecificationParts(root);
   inExecutionPart_ = true;
   ResolveExecutionParts(root);
   inExecutionPart_ = false;
   ResolveAccParts(context(), x);

flang/test/Parser/compiler-directives.f90

 ! RUN: %f18 -funparse %s 2>&1
 
 ! Test that compiler directives can appear in various places.
 
+!dir$ integer
 module m
   !dir$ integer
   use iso_fortran_env
   !dir$ integer
   implicit integer(a-z)
   !dir$ integer
 end