[flang] Allow compiler directives in the specification part of a module

[vdonaldson]

Summary

Lowering code currently allows for directives inside a program or
subprogram, or outside any program unit. Directives may also appear
in the specification part of a module, as in:

module mm
  interface
     subroutine ss(aa)
       !dir$ ignore_tkr(tkr) aa
       integer :: aa(*)
     end subroutine ss
  end interface
end module

With some exceptions such as OpenMP directives, most directives are
currently ignored, so this code should generate an "ignoring all compiler
directives" message.

[clementval]

LGTM

[vdonaldson]

https://reviews.llvm.org/D143105

flang/lib/Lower/PFTBuilder.cpp

private:
   }
 
   /// Append an Evaluation to the end of the current list.
   lower::pft::Evaluation &addEvaluation(lower::pft::Evaluation &&eval) {
     assert(functionList && "not in a function");
     assert(!evaluationListStack.empty() && "empty evaluation list stack");
     if (!constructAndDirectiveStack.empty())
       eval.parentConstruct = constructAndDirectiveStack.back();
-    auto &entryPointList = eval.getOwningProcedure()->entryPointList;
+    lower::pft::FunctionLikeUnit *owningProcedure = eval.getOwningProcedure();
     evaluationListStack.back()->emplace_back(std::move(eval));
     lower::pft::Evaluation *p = &evaluationListStack.back()->back();
     if (p->isActionStmt() || p->isConstructStmt() || p->isEndStmt() ||
         p->isExecutableDirective()) {
       if (lastLexicalEvaluation) {
         lastLexicalEvaluation->lexicalSuccessor = p;
         p->printIndex = lastLexicalEvaluation->printIndex + 1;
       } else {
         p->printIndex = 1;
       }
       lastLexicalEvaluation = p;
+      if (owningProcedure) {
+        auto &entryPointList = owningProcedure->entryPointList;
         for (std::size_t entryIndex = entryPointList.size() - 1;
              entryIndex && !entryPointList[entryIndex].second->lexicalSuccessor;
              --entryIndex)
           // Link to the entry's first executable statement.
           entryPointList[entryIndex].second->lexicalSuccessor = p;
+      }
     } else if (const auto *entryStmt = p->getIf<parser::EntryStmt>()) {
       const semantics::Symbol *sym =
           std::get<parser::Name>(entryStmt->t).symbol;
       if (auto *details = sym->detailsIf<semantics::GenericDetails>())
         sym = details->specific();
       assert(sym->has<semantics::SubprogramDetails>() &&
              "entry must be a subprogram");
-      entryPointList.push_back(std::pair{sym, p});
+      owningProcedure->entryPointList.push_back(std::pair{sym, p});
     }
     if (p->label.has_value())
       labelEvaluationMap->try_emplace(*p->label, p);
     return evaluationListStack.back()->back();
   }
 
   /// push a new list on the stack of Evaluation lists
   void pushEvaluationList(lower::pft::EvaluationList *evaluationList) {

flang/test/Lower/pre-fir-tree02.f90

module test
   !!  - !![disable]
   !!  -  COM: 
   !![disable]type :: a_type
   !![disable]  integer :: x
   !![disable]end type
   !![disable]type, extends(a_type) :: b_type
   !![disable]  integer :: y
   !![disable]end type
+  interface
+     subroutine ss(aa)
+       ! CHECK: CompilerDirective
+       !DIR$ IGNORE_TKR aa
+       integer :: aa
+     end subroutine ss
+  end interface
 contains
   ! CHECK: Function foo
   function foo(x)
     real x(..)
     integer :: foo
     ! CHECK: <<SelectRankConstruct!>>
     ! CHECK: SelectRankStmt
     select rank(x)
function bar(x)
     ! CHECK: EndSelectStmt
     end select
     ! CHECK: <<End SelectTypeConstruct!>>
   end function
 
   ! CHECK: Subroutine sub
   subroutine sub(a)
     real(4):: a
-    ! CompilerDirective:
+    ! CHECK: CompilerDirective
     !DIR$ IGNORE_TKR a
   end subroutine
 
 
 end module
 
 ! CHECK: Subroutine altreturn
 subroutine altreturn(i, j, *, *)