[flang][NFC] Unify OpenMP and OpenACC structure checker

[clementval]

Summary

This patch remove duplicated code between the check-omp-structure and the check-acc-structure
and unify it into a check-directive-structure templated class.

[kiranchandramohan]

LGTM. Please wait for one more approval.

[clementval]

Fix directive1 and directive2 tests

[clementval]

In D85104#2194431, @kiranchandramohan wrote:

LGTM. Please wait for one more approval.

Thanks for the review. I noticed that the lit tests were failing. Just updated the patch to fix them.

[clementval]

@ichoyjx can you have a look?

[ichoyjx]

flang/lib/Semantics/check-directive-structure.h

31

Quick question, PC stands for?

flang/lib/Semantics/check-omp-structure.cpp

43

Adding CheckMatching into all the Enter functions is a good move.

[clementval]

Thanks for the reviews. Will try to push that today.

flang/lib/Semantics/check-directive-structure.h

31

ParserClass ... was trying to have short typename to not clutter the code too much. I'll add a comment on the class definition to mention what is what.

flang/lib/Semantics/check-acc-structure.h

 //===-- lib/Semantics/check-acc-structure.h ---------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 // OpenACC structure validity check list
 //    1. invalid clauses on directive
 //    2. invalid repeated clauses on directive
 //    3. invalid nesting of regions
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_SEMANTICS_CHECK_ACC_STRUCTURE_H_
 #define FORTRAN_SEMANTICS_CHECK_ACC_STRUCTURE_H_
 
+#include "check-directive-structure.h"
 #include "flang/Common/enum-set.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/semantics.h"
 #include "llvm/Frontend/OpenACC/ACC.h.inc"
 
-#include <unordered_map>
-
 using AccDirectiveSet = Fortran::common::EnumSet<llvm::acc::Directive,
     llvm::acc::Directive_enumSize>;
 
 using AccClauseSet =
     Fortran::common::EnumSet<llvm::acc::Clause, llvm::acc::Clause_enumSize>;
 
 #define GEN_FLANG_DIRECTIVE_CLAUSE_SETS
 #include "llvm/Frontend/OpenACC/ACC.cpp.inc"
 
 namespace Fortran::semantics {
 
-class AccStructureChecker : public virtual BaseChecker {
+class AccStructureChecker
+    : public DirectiveStructureChecker<llvm::acc::Directive, llvm::acc::Clause,
+          parser::AccClause, llvm::acc::Clause_enumSize> {
 public:
-  AccStructureChecker(SemanticsContext &context) : context_{context} {}
+  AccStructureChecker(SemanticsContext &context)
+      : DirectiveStructureChecker(context,
+#define GEN_FLANG_DIRECTIVE_CLAUSE_MAP
+#include "llvm/Frontend/OpenACC/ACC.cpp.inc"
+        ) {
+  }
 
   // Construct and directives
   void Enter(const parser::OpenACCBlockConstruct &);
   void Leave(const parser::OpenACCBlockConstruct &);
   void Enter(const parser::OpenACCCombinedConstruct &);
   void Leave(const parser::OpenACCCombinedConstruct &);
   void Enter(const parser::OpenACCLoopConstruct &);
   void Leave(const parser::OpenACCLoopConstruct &);
#include "llvm/Frontend/OpenACC/ACC.cpp.inc"
   void Enter(const parser::AccClause::UseDevice &);
   void Enter(const parser::AccClause::Vector &);
   void Enter(const parser::AccClause::VectorLength &);
   void Enter(const parser::AccClause::Wait &);
   void Enter(const parser::AccClause::Worker &);
   void Enter(const parser::AccClause::Write &);
 
 private:
-#define GEN_FLANG_DIRECTIVE_CLAUSE_MAP
-#include "llvm/Frontend/OpenACC/ACC.cpp.inc"
-
-  struct AccContext {
-    AccContext(parser::CharBlock source, llvm::acc::Directive d)
-        : directiveSource{source}, directive{d} {}
-
-    parser::CharBlock directiveSource{nullptr};
-    parser::CharBlock clauseSource{nullptr};
-    llvm::acc::Directive directive;
-    AccClauseSet allowedClauses{};
-    AccClauseSet allowedOnceClauses{};
-    AccClauseSet allowedExclusiveClauses{};
-    AccClauseSet requiredClauses{};
-
-    const parser::AccClause *clause{nullptr};
-    std::multimap<llvm::acc::Clause, const parser::AccClause *> clauseInfo;
-    std::list<llvm::acc::Clause> actualClauses;
-  };
-
-  // back() is the top of the stack
-  AccContext &GetContext() {
-    CHECK(!accContext_.empty());
-    return accContext_.back();
-  }
-
-  void SetContextClause(const parser::AccClause &clause) {
-    GetContext().clauseSource = clause.source;
-    GetContext().clause = &clause;
-  }
-
-  void SetContextClauseInfo(llvm::acc::Clause type) {
-    GetContext().clauseInfo.emplace(type, GetContext().clause);
-  }
-
-  void AddClauseToCrtContext(llvm::acc::Clause type) {
-    GetContext().actualClauses.push_back(type);
-  }
-
-  const parser::AccClause *FindClause(llvm::acc::Clause type) {
-    auto it{GetContext().clauseInfo.find(type)};
-    if (it != GetContext().clauseInfo.end()) {
-      return it->second;
-    }
-    return nullptr;
-  }
-
-  void PushContext(const parser::CharBlock &source, llvm::acc::Directive dir) {
-    accContext_.emplace_back(source, dir);
-  }
-
-  void SetClauseSets(llvm::acc::Directive dir) {
-    accContext_.back().allowedClauses = directiveClausesTable[dir].allowed;
-    accContext_.back().allowedOnceClauses =
-        directiveClausesTable[dir].allowedOnce;
-    accContext_.back().allowedExclusiveClauses =
-        directiveClausesTable[dir].allowedExclusive;
-    accContext_.back().requiredClauses =
-        directiveClausesTable[dir].requiredOneOf;
-  }
-  void PushContextAndClauseSets(
-      const parser::CharBlock &source, llvm::acc::Directive dir) {
-    PushContext(source, dir);
-    SetClauseSets(dir);
-  }
-
-  void SayNotMatching(const parser::CharBlock &, const parser::CharBlock &);
-
-  template <typename B> void CheckMatching(const B &beginDir, const B &endDir) {
-    const auto &begin{beginDir.v};
-    const auto &end{endDir.v};
-    if (begin != end) {
-      SayNotMatching(beginDir.source, endDir.source);
-    }
-  }
-
-  // Check that only clauses in set are after the specific clauses.
-  void CheckOnlyAllowedAfter(llvm::acc::Clause clause, AccClauseSet set);
-  void CheckRequireAtLeastOneOf();
-  void CheckAllowed(llvm::acc::Clause clause);
-  void CheckAtLeastOneClause();
-  void CheckNotAllowedIfClause(llvm::acc::Clause clause, AccClauseSet set);
-  std::string ContextDirectiveAsFortran();
 
   void CheckNoBranching(const parser::Block &block,
       const llvm::acc::Directive directive,
       const parser::CharBlock &directiveSource) const;
 
-  void RequiresConstantPositiveParameter(
-      const llvm::acc::Clause &clause, const parser::ScalarIntConstantExpr &i);
-  void OptionalConstantPositiveParameter(const llvm::acc::Clause &clause,
-      const std::optional<parser::ScalarIntConstantExpr> &o);
-
-  SemanticsContext &context_;
-  std::vector<AccContext> accContext_; // used as a stack
-
-  std::string ClauseSetToString(const AccClauseSet set);
+  llvm::StringRef getClauseName(llvm::acc::Clause clause) override;
+  llvm::StringRef getDirectiveName(llvm::acc::Directive directive) override;
 };
 
 } // namespace Fortran::semantics
 
 #endif // FORTRAN_SEMANTICS_CHECK_ACC_STRUCTURE_H_

flang/lib/Semantics/check-acc-structure.cpp

case llvm::acc::Directive::ACCD_data:
     break;
   case llvm::acc::Directive::ACCD_host_data:
     // Restriction - 1578
     CheckRequireAtLeastOneOf();
     break;
   default:
     break;
   }
-  accContext_.pop_back();
+  dirContext_.pop_back();
 }
 
 void AccStructureChecker::CheckNoBranching(const parser::Block &block,
     const llvm::acc::Directive directive,
     const parser::CharBlock &directiveSource) const {
   NoBranchingEnforce noBranchingEnforce{context_, directiveSource, directive};
   parser::Walk(block, noBranchingEnforce);
 }
 
 void AccStructureChecker::Enter(
     const parser::OpenACCStandaloneDeclarativeConstruct &x) {
   const auto &declarativeDir{std::get<parser::AccDeclarativeDirective>(x.t)};
   PushContextAndClauseSets(declarativeDir.source, declarativeDir.v);
 }
 
 void AccStructureChecker::Leave(
     const parser::OpenACCStandaloneDeclarativeConstruct &) {
   // Restriction - 2075
   CheckAtLeastOneClause();
-  accContext_.pop_back();
+  dirContext_.pop_back();
 }
 
 void AccStructureChecker::Enter(const parser::OpenACCCombinedConstruct &x) {
   const auto &beginBlockDir{std::get<parser::AccBeginCombinedDirective>(x.t)};
   const auto &combinedDir{
       std::get<parser::AccCombinedDirective>(beginBlockDir.t)};
   PushContextAndClauseSets(combinedDir.source, combinedDir.v);
 }
void AccStructureChecker::Leave(const parser::OpenACCCombinedConstruct &x) {
   case llvm::acc::Directive::ACCD_serial_loop:
     // Restriction - 1962 -> (919) (SERIAL LOOP)
     CheckOnlyAllowedAfter(llvm::acc::Clause::ACCC_device_type,
         {llvm::acc::Clause::ACCC_async, llvm::acc::Clause::ACCC_wait});
     break;
   default:
     break;
   }
-  accContext_.pop_back();
-}
-
-std::string AccStructureChecker::ContextDirectiveAsFortran() {
-  return parser::ToUpperCaseLetters(
-      llvm::acc::getOpenACCDirectiveName(GetContext().directive).str());
+  dirContext_.pop_back();
 }
 
 void AccStructureChecker::Enter(const parser::OpenACCLoopConstruct &x) {
   const auto &beginDir{std::get<parser::AccBeginLoopDirective>(x.t)};
   const auto &loopDir{std::get<parser::AccLoopDirective>(beginDir.t)};
   PushContextAndClauseSets(loopDir.source, loopDir.v);
 }
 
 void AccStructureChecker::Leave(const parser::OpenACCLoopConstruct &x) {
   const auto &beginDir{std::get<parser::AccBeginLoopDirective>(x.t)};
   const auto &loopDir{std::get<parser::AccLoopDirective>(beginDir.t)};
   if (loopDir.v == llvm::acc::Directive::ACCD_loop) {
     // Restriction - 1615-1616
     CheckOnlyAllowedAfter(llvm::acc::Clause::ACCC_device_type,
         loopOnlyAllowedAfterDeviceTypeClauses);
     // Restriction - 1622
     CheckNotAllowedIfClause(llvm::acc::Clause::ACCC_seq,
         {llvm::acc::Clause::ACCC_gang, llvm::acc::Clause::ACCC_vector,
             llvm::acc::Clause::ACCC_worker});
   }
-  accContext_.pop_back();
+  dirContext_.pop_back();
 }
 
 void AccStructureChecker::Enter(const parser::OpenACCStandaloneConstruct &x) {
   const auto &standaloneDir{std::get<parser::AccStandaloneDirective>(x.t)};
   PushContextAndClauseSets(standaloneDir.source, standaloneDir.v);
 }
 
 void AccStructureChecker::Leave(const parser::OpenACCStandaloneConstruct &x) {
void AccStructureChecker::Leave(const parser::OpenACCStandaloneConstruct &x) {
   case llvm::acc::Directive::ACCD_update:
     // Restriction - 2301
     CheckOnlyAllowedAfter(llvm::acc::Clause::ACCC_device_type,
         updateOnlyAllowedAfterDeviceTypeClauses);
     break;
   default:
     break;
   }
-  accContext_.pop_back();
+  dirContext_.pop_back();
 }
 
 void AccStructureChecker::Enter(const parser::OpenACCRoutineConstruct &x) {
   PushContextAndClauseSets(x.source, llvm::acc::Directive::ACCD_routine);
 }
 void AccStructureChecker::Leave(const parser::OpenACCRoutineConstruct &) {
   // Restriction - 2409
   CheckRequireAtLeastOneOf();
   // Restriction - 2407-2408
   CheckOnlyAllowedAfter(llvm::acc::Clause::ACCC_device_type,
       routineOnlyAllowedAfterDeviceTypeClauses);
-  accContext_.pop_back();
+  dirContext_.pop_back();
 }
 
 // Clause checkers
 CHECK_REQ_SCALAR_INT_CONSTANT_CLAUSE(Collapse, ACCC_collapse)
 
 CHECK_SIMPLE_CLAUSE(Auto, ACCC_auto)
 CHECK_SIMPLE_CLAUSE(Async, ACCC_async)
 CHECK_SIMPLE_CLAUSE(Attach, ACCC_attach)
if (modifier->v != parser::AccDataModifier::Modifier::Zero) {
           parser::ToUpperCaseLetters(
               llvm::acc::getOpenACCClauseName(llvm::acc::Clause::ACCC_copyout)
                   .str()),
           ContextDirectiveAsFortran());
     }
   }
 }
 
-void AccStructureChecker::CheckAllowed(llvm::acc::Clause clause) {
-  if (!GetContext().allowedClauses.test(clause) &&
-      !GetContext().allowedOnceClauses.test(clause) &&
-      !GetContext().allowedExclusiveClauses.test(clause) &&
-      !GetContext().requiredClauses.test(clause)) {
-    context_.Say(GetContext().clauseSource,
-        "%s clause is not allowed on the %s directive"_err_en_US,
-        parser::ToUpperCaseLetters(
-            llvm::acc::getOpenACCClauseName(clause).str()),
-        parser::ToUpperCaseLetters(GetContext().directiveSource.ToString()));
-    return;
-  }
-  if ((GetContext().allowedOnceClauses.test(clause) ||
-          GetContext().allowedExclusiveClauses.test(clause)) &&
-      FindClause(clause)) {
-    context_.Say(GetContext().clauseSource,
-        "At most one %s clause can appear on the %s directive"_err_en_US,
-        parser::ToUpperCaseLetters(
-            llvm::acc::getOpenACCClauseName(clause).str()),
-        parser::ToUpperCaseLetters(GetContext().directiveSource.ToString()));
-    return;
-  }
-  if (GetContext().allowedExclusiveClauses.test(clause)) {
-    std::vector<llvm::acc::Clause> others;
-    GetContext().allowedExclusiveClauses.IterateOverMembers(
-        [&](llvm::acc::Clause o) {
-          if (FindClause(o)) {
-            others.emplace_back(o);
-          }
-        });
-    for (const auto &e : others) {
-      context_.Say(GetContext().clauseSource,
-          "%s and %s clauses are mutually exclusive and may not appear on the "
-          "same %s directive"_err_en_US,
-          parser::ToUpperCaseLetters(
-              llvm::acc::getOpenACCClauseName(clause).str()),
-          parser::ToUpperCaseLetters(llvm::acc::getOpenACCClauseName(e).str()),
-          parser::ToUpperCaseLetters(GetContext().directiveSource.ToString()));
-    }
-    if (!others.empty()) {
-      return;
-    }
-  }
-  SetContextClauseInfo(clause);
-  AddClauseToCrtContext(clause);
-}
-
-void AccStructureChecker::CheckOnlyAllowedAfter(
-    llvm::acc::Clause clause, AccClauseSet set) {
-  bool enforceCheck = false;
-  for (auto cl : GetContext().actualClauses) {
-    if (cl == clause) {
-      enforceCheck = true;
-      continue;
-    } else if (enforceCheck && !set.test(cl)) {
-      auto parserClause = GetContext().clauseInfo.find(cl);
-      context_.Say(parserClause->second->source,
-          "Clause %s is not allowed after clause %s on the %s "
-          "directive"_err_en_US,
-          parser::ToUpperCaseLetters(llvm::acc::getOpenACCClauseName(cl).str()),
-          parser::ToUpperCaseLetters(
-              llvm::acc::getOpenACCClauseName(clause).str()),
-          ContextDirectiveAsFortran());
-    }
-  }
-}
-
-void AccStructureChecker::CheckRequireAtLeastOneOf() {
-  for (auto cl : GetContext().actualClauses) {
-    if (GetContext().requiredClauses.test(cl))
-      return;
-  }
-  // No clause matched in the actual clauses list
-  context_.Say(GetContext().directiveSource,
-      "At least one of %s clause must appear on the %s directive"_err_en_US,
-      ClauseSetToString(GetContext().requiredClauses),
-      ContextDirectiveAsFortran());
+llvm::StringRef AccStructureChecker::getClauseName(llvm::acc::Clause clause) {
+  return llvm::acc::getOpenACCClauseName(clause);
 }
 
-void AccStructureChecker::CheckAtLeastOneClause() {
-  if (GetContext().actualClauses.empty()) {
-    context_.Say(GetContext().directiveSource,
-        "At least one clause is required on the %s directive"_err_en_US,
-        ContextDirectiveAsFortran());
-  }
-}
-
-// Enforce restriction where clauses in the given set are not allowed if the
-// given clause appears.
-void AccStructureChecker::CheckNotAllowedIfClause(
-    llvm::acc::Clause clause, AccClauseSet set) {
-  if (std::find(GetContext().actualClauses.begin(),
-          GetContext().actualClauses.end(),
-          clause) == GetContext().actualClauses.end()) {
-    return; // Clause is not present
-  }
-
-  for (auto cl : GetContext().actualClauses) {
-    if (set.test(cl)) {
-      context_.Say(GetContext().directiveSource,
-          "Clause %s is not allowed if clause %s appears on the %s directive"_err_en_US,
-          parser::ToUpperCaseLetters(llvm::acc::getOpenACCClauseName(cl).str()),
-          parser::ToUpperCaseLetters(
-              llvm::acc::getOpenACCClauseName(clause).str()),
-          ContextDirectiveAsFortran());
-    }
-  }
-}
-
-void AccStructureChecker::RequiresConstantPositiveParameter(
-    const llvm::acc::Clause &clause, const parser::ScalarIntConstantExpr &i) {
-  if (const auto v{GetIntValue(i)}) {
-    if (*v <= 0) {
-      context_.Say(GetContext().clauseSource,
-          "The parameter of the %s clause on the %s directive must be "
-          "a constant positive integer expression"_err_en_US,
-          parser::ToUpperCaseLetters(
-              llvm::acc::getOpenACCClauseName(clause).str()),
-          ContextDirectiveAsFortran());
-    }
-  }
-}
-
-void AccStructureChecker::OptionalConstantPositiveParameter(
-    const llvm::acc::Clause &clause,
-    const std::optional<parser::ScalarIntConstantExpr> &o) {
-  if (o != std::nullopt) {
-    RequiresConstantPositiveParameter(clause, o.value());
-  }
-}
-
-std::string AccStructureChecker::ClauseSetToString(const AccClauseSet set) {
-  std::string list;
-  set.IterateOverMembers([&](llvm::acc::Clause o) {
-    if (!list.empty())
-      list.append(", ");
-    list.append(
-        parser::ToUpperCaseLetters(llvm::acc::getOpenACCClauseName(o).str()));
-  });
-  return list;
-}
-
-void AccStructureChecker::SayNotMatching(
-    const parser::CharBlock &beginSource, const parser::CharBlock &endSource) {
-  context_
-      .Say(endSource, "Unmatched %s directive"_err_en_US,
-          parser::ToUpperCaseLetters(endSource.ToString()))
-      .Attach(beginSource, "Does not match directive"_en_US);
+llvm::StringRef AccStructureChecker::getDirectiveName(
+    llvm::acc::Directive directive) {
+  return llvm::acc::getOpenACCDirectiveName(directive);
 }
 
 } // namespace Fortran::semantics

flang/lib/Semantics/check-directive-structure.h

+//===-- lib/Semantics/check-directive-structure.h ---------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Directive structure validity checks common to OpenMP, OpenACC and other
+// directive language.
+
+#ifndef FORTRAN_SEMANTICS_CHECK_DIRECTIVE_STRUCTURE_H_
+#define FORTRAN_SEMANTICS_CHECK_DIRECTIVE_STRUCTURE_H_
+
+#include "flang/Common/enum-set.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/tools.h"
+
+#include <unordered_map>
+
+namespace Fortran::semantics {
+
+template <typename C, std::size_t ClauseEnumSize> struct DirectiveClauses {
+  const common::EnumSet<C, ClauseEnumSize> allowed;
+  const common::EnumSet<C, ClauseEnumSize> allowedOnce;
+  const common::EnumSet<C, ClauseEnumSize> allowedExclusive;
+  const common::EnumSet<C, ClauseEnumSize> requiredOneOf;
+};
+
+// Generic structure checker for directives/clauses language such as OpenMP
+// and OpenACC.
+// typename D is the directive enumeration.
+// tyepname C is the clause enumeration.
+// typename PC is the parser class defined in parse-tree.h for the clauses.
+template <typename D, typename C, typename PC, std::size_t ClauseEnumSize>
+class DirectiveStructureChecker : public virtual BaseChecker {
+public:
+  DirectiveStructureChecker(SemanticsContext &context,
+      std::unordered_map<D, DirectiveClauses<C, ClauseEnumSize>>
+          directiveClausesMap)
+      : context_{context}, directiveClausesMap_(directiveClausesMap) {}
+
+protected:
+  struct DirectiveContext {
+    DirectiveContext(parser::CharBlock source, D d)
+        : directiveSource{source}, directive{d} {}
+
+    parser::CharBlock directiveSource{nullptr};
+    parser::CharBlock clauseSource{nullptr};
+    D directive;
+    common::EnumSet<C, ClauseEnumSize> allowedClauses{};
+    common::EnumSet<C, ClauseEnumSize> allowedOnceClauses{};
+    common::EnumSet<C, ClauseEnumSize> allowedExclusiveClauses{};
+    common::EnumSet<C, ClauseEnumSize> requiredClauses{};
+
+    const PC *clause{nullptr};
+    std::multimap<C, const PC *> clauseInfo;
+    std::list<C> actualClauses;
+  };
+
+  // back() is the top of the stack
+  DirectiveContext &GetContext() {
+    CHECK(!dirContext_.empty());
+    return dirContext_.back();
+  }
+
+  void SetContextClause(const PC &clause) {
+    GetContext().clauseSource = clause.source;
+    GetContext().clause = &clause;
+  }
+
+  void ResetPartialContext(const parser::CharBlock &source) {
+    CHECK(!dirContext_.empty());
+    SetContextDirectiveSource(source);
+    GetContext().allowedClauses = {};
+    GetContext().allowedOnceClauses = {};
+    GetContext().allowedExclusiveClauses = {};
+    GetContext().requiredClauses = {};
+    GetContext().clauseInfo = {};
+  }
+
+  void SetContextDirectiveSource(const parser::CharBlock &directive) {
+    GetContext().directiveSource = directive;
+  }
+
+  void SetContextDirectiveEnum(D dir) { GetContext().directive = dir; }
+
+  void SetContextAllowed(const common::EnumSet<C, ClauseEnumSize> &allowed) {
+    GetContext().allowedClauses = allowed;
+  }
+
+  void SetContextAllowedOnce(
+      const common::EnumSet<C, ClauseEnumSize> &allowedOnce) {
+    GetContext().allowedOnceClauses = allowedOnce;
+  }
+
+  void SetContextAllowedExclusive(
+      const common::EnumSet<C, ClauseEnumSize> &allowedExclusive) {
+    GetContext().allowedExclusiveClauses = allowedExclusive;
+  }
+
+  void SetContextRequired(const common::EnumSet<C, ClauseEnumSize> &required) {
+    GetContext().requiredClauses = required;
+  }
+
+  void SetContextClauseInfo(C type) {
+    GetContext().clauseInfo.emplace(type, GetContext().clause);
+  }
+
+  void AddClauseToCrtContext(C type) {
+    GetContext().actualClauses.push_back(type);
+  }
+
+  const PC *FindClause(C type) {
+    auto it{GetContext().clauseInfo.find(type)};
+    if (it != GetContext().clauseInfo.end()) {
+      return it->second;
+    }
+    return nullptr;
+  }
+
+  void PushContext(const parser::CharBlock &source, D dir) {
+    dirContext_.emplace_back(source, dir);
+  }
+
+  bool CurrentDirectiveIsNested() { return dirContext_.size() > 0; };
+
+  void SetClauseSets(D dir) {
+    dirContext_.back().allowedClauses = directiveClausesMap_[dir].allowed;
+    dirContext_.back().allowedOnceClauses =
+        directiveClausesMap_[dir].allowedOnce;
+    dirContext_.back().allowedExclusiveClauses =
+        directiveClausesMap_[dir].allowedExclusive;
+    dirContext_.back().requiredClauses =
+        directiveClausesMap_[dir].requiredOneOf;
+  }
+  void PushContextAndClauseSets(const parser::CharBlock &source, D dir) {
+    PushContext(source, dir);
+    SetClauseSets(dir);
+  }
+
+  void SayNotMatching(const parser::CharBlock &, const parser::CharBlock &);
+
+  template <typename B> void CheckMatching(const B &beginDir, const B &endDir) {
+    const auto &begin{beginDir.v};
+    const auto &end{endDir.v};
+    if (begin != end) {
+      SayNotMatching(beginDir.source, endDir.source);
+    }
+  }
+
+  // Check that only clauses in set are after the specific clauses.
+  void CheckOnlyAllowedAfter(C clause, common::EnumSet<C, ClauseEnumSize> set);
+
+  void CheckRequired(C clause);
+
+  void CheckRequireAtLeastOneOf();
+
+  void CheckAllowed(C clause);
+
+  void CheckAtLeastOneClause();
+
+  void CheckNotAllowedIfClause(
+      C clause, common::EnumSet<C, ClauseEnumSize> set);
+
+  std::string ContextDirectiveAsFortran();
+
+  void RequiresConstantPositiveParameter(
+      const C &clause, const parser::ScalarIntConstantExpr &i);
+
+  void RequiresPositiveParameter(
+      const C &clause, const parser::ScalarIntExpr &i);
+
+  void OptionalConstantPositiveParameter(
+      const C &clause, const std::optional<parser::ScalarIntConstantExpr> &o);
+
+  virtual llvm::StringRef getClauseName(C clause) { return ""; };
+
+  virtual llvm::StringRef getDirectiveName(D directive) { return ""; };
+
+  SemanticsContext &context_;
+  std::vector<DirectiveContext> dirContext_; // used as a stack
+  std::unordered_map<D, DirectiveClauses<C, ClauseEnumSize>>
+      directiveClausesMap_;
+
+  std::string ClauseSetToString(const common::EnumSet<C, ClauseEnumSize> set);
+};
+
+// Check that only clauses included in the given set are present after the given
+// clause.
+template <typename D, typename C, typename PC, std::size_t ClauseEnumSize>
+void DirectiveStructureChecker<D, C, PC, ClauseEnumSize>::CheckOnlyAllowedAfter(
+    C clause, common::EnumSet<C, ClauseEnumSize> set) {
+  bool enforceCheck = false;
+  for (auto cl : GetContext().actualClauses) {
+    if (cl == clause) {
+      enforceCheck = true;
+      continue;
+    } else if (enforceCheck && !set.test(cl)) {
+      auto parserClause = GetContext().clauseInfo.find(cl);
+      context_.Say(parserClause->second->source,
+          "Clause %s is not allowed after clause %s on the %s "
+          "directive"_err_en_US,
+          parser::ToUpperCaseLetters(getClauseName(cl).str()),
+          parser::ToUpperCaseLetters(getClauseName(clause).str()),
+          ContextDirectiveAsFortran());
+    }
+  }
+}
+
+// Check that at least one clause is attached to the directive.
+template <typename D, typename C, typename PC, std::size_t ClauseEnumSize>
+void DirectiveStructureChecker<D, C, PC,
+    ClauseEnumSize>::CheckAtLeastOneClause() {
+  if (GetContext().actualClauses.empty()) {
+    context_.Say(GetContext().directiveSource,
+        "At least one clause is required on the %s directive"_err_en_US,
+        ContextDirectiveAsFortran());
+  }
+}
+
+template <typename D, typename C, typename PC, std::size_t ClauseEnumSize>
+std::string
+DirectiveStructureChecker<D, C, PC, ClauseEnumSize>::ClauseSetToString(
+    const common::EnumSet<C, ClauseEnumSize> set) {
+  std::string list;
+  set.IterateOverMembers([&](C o) {
+    if (!list.empty())
+      list.append(", ");
+    list.append(parser::ToUpperCaseLetters(getClauseName(o).str()));
+  });
+  return list;
+}
+
+// Check that at least one clause in the required set is present on the
+// directive.
+template <typename D, typename C, typename PC, std::size_t ClauseEnumSize>
+void DirectiveStructureChecker<D, C, PC,
+    ClauseEnumSize>::CheckRequireAtLeastOneOf() {
+  for (auto cl : GetContext().actualClauses) {
+    if (GetContext().requiredClauses.test(cl))
+      return;
+  }
+  // No clause matched in the actual clauses list
+  context_.Say(GetContext().directiveSource,
+      "At least one of %s clause must appear on the %s directive"_err_en_US,
+      ClauseSetToString(GetContext().requiredClauses),
+      ContextDirectiveAsFortran());
+}
+
+template <typename D, typename C, typename PC, std::size_t ClauseEnumSize>
+std::string DirectiveStructureChecker<D, C, PC,
+    ClauseEnumSize>::ContextDirectiveAsFortran() {
+  return parser::ToUpperCaseLetters(
+      getDirectiveName(GetContext().directive).str());
+}
+
+// Check that clauses present on the directive are allowed clauses.
+template <typename D, typename C, typename PC, std::size_t ClauseEnumSize>
+void DirectiveStructureChecker<D, C, PC, ClauseEnumSize>::CheckAllowed(
+    C clause) {
+  if (!GetContext().allowedClauses.test(clause) &&
+      !GetContext().allowedOnceClauses.test(clause) &&
+      !GetContext().allowedExclusiveClauses.test(clause) &&
+      !GetContext().requiredClauses.test(clause)) {
+    context_.Say(GetContext().clauseSource,
+        "%s clause is not allowed on the %s directive"_err_en_US,
+        parser::ToUpperCaseLetters(getClauseName(clause).str()),
+        parser::ToUpperCaseLetters(GetContext().directiveSource.ToString()));
+    return;
+  }
+  if ((GetContext().allowedOnceClauses.test(clause) ||
+          GetContext().allowedExclusiveClauses.test(clause)) &&
+      FindClause(clause)) {
+    context_.Say(GetContext().clauseSource,
+        "At most one %s clause can appear on the %s directive"_err_en_US,
+        parser::ToUpperCaseLetters(getClauseName(clause).str()),
+        parser::ToUpperCaseLetters(GetContext().directiveSource.ToString()));
+    return;
+  }
+  if (GetContext().allowedExclusiveClauses.test(clause)) {
+    std::vector<C> others;
+    GetContext().allowedExclusiveClauses.IterateOverMembers([&](C o) {
+      if (FindClause(o)) {
+        others.emplace_back(o);
+      }
+    });
+    for (const auto &e : others) {
+      context_.Say(GetContext().clauseSource,
+          "%s and %s clauses are mutually exclusive and may not appear on the "
+          "same %s directive"_err_en_US,
+          parser::ToUpperCaseLetters(getClauseName(clause).str()),
+          parser::ToUpperCaseLetters(getClauseName(e).str()),
+          parser::ToUpperCaseLetters(GetContext().directiveSource.ToString()));
+    }
+    if (!others.empty()) {
+      return;
+    }
+  }
+  SetContextClauseInfo(clause);
+  AddClauseToCrtContext(clause);
+}
+
+// Enforce restriction where clauses in the given set are not allowed if the
+// given clause appears.
+template <typename D, typename C, typename PC, std::size_t ClauseEnumSize>
+void DirectiveStructureChecker<D, C, PC,
+    ClauseEnumSize>::CheckNotAllowedIfClause(C clause,
+    common::EnumSet<C, ClauseEnumSize> set) {
+  if (std::find(GetContext().actualClauses.begin(),
+          GetContext().actualClauses.end(),
+          clause) == GetContext().actualClauses.end()) {
+    return; // Clause is not present
+  }
+
+  for (auto cl : GetContext().actualClauses) {
+    if (set.test(cl)) {
+      context_.Say(GetContext().directiveSource,
+          "Clause %s is not allowed if clause %s appears on the %s directive"_err_en_US,
+          parser::ToUpperCaseLetters(getClauseName(cl).str()),
+          parser::ToUpperCaseLetters(getClauseName(clause).str()),
+          ContextDirectiveAsFortran());
+    }
+  }
+}
+
+// Check the value of the clause is a constant positive integer.
+template <typename D, typename C, typename PC, std::size_t ClauseEnumSize>
+void DirectiveStructureChecker<D, C, PC,
+    ClauseEnumSize>::RequiresConstantPositiveParameter(const C &clause,
+    const parser::ScalarIntConstantExpr &i) {
+  if (const auto v{GetIntValue(i)}) {
+    if (*v <= 0) {
+      context_.Say(GetContext().clauseSource,
+          "The parameter of the %s clause must be "
+          "a constant positive integer expression"_err_en_US,
+          parser::ToUpperCaseLetters(getClauseName(clause).str()));
+    }
+  }
+}
+
+// Check the value of the clause is a constant positive parameter.
+template <typename D, typename C, typename PC, std::size_t ClauseEnumSize>
+void DirectiveStructureChecker<D, C, PC,
+    ClauseEnumSize>::OptionalConstantPositiveParameter(const C &clause,
+    const std::optional<parser::ScalarIntConstantExpr> &o) {
+  if (o != std::nullopt) {
+    RequiresConstantPositiveParameter(clause, o.value());
+  }
+}
+
+template <typename D, typename C, typename PC, std::size_t ClauseEnumSize>
+void DirectiveStructureChecker<D, C, PC, ClauseEnumSize>::SayNotMatching(
+    const parser::CharBlock &beginSource, const parser::CharBlock &endSource) {
+  context_
+      .Say(endSource, "Unmatched %s directive"_err_en_US,
+          parser::ToUpperCaseLetters(endSource.ToString()))
+      .Attach(beginSource, "Does not match directive"_en_US);
+}
+
+// Check that at least one of the required clauses is present on the directive.
+template <typename D, typename C, typename PC, std::size_t ClauseEnumSize>
+void DirectiveStructureChecker<D, C, PC, ClauseEnumSize>::CheckRequired(C c) {
+  if (!FindClause(c)) {
+    context_.Say(GetContext().directiveSource,
+        "At least one %s clause must appear on the %s directive"_err_en_US,
+        parser::ToUpperCaseLetters(getClauseName(c).str()),
+        ContextDirectiveAsFortran());
+  }
+}
+
+// Check the value of the clause is a positive parameter.
+template <typename D, typename C, typename PC, std::size_t ClauseEnumSize>
+void DirectiveStructureChecker<D, C, PC,
+    ClauseEnumSize>::RequiresPositiveParameter(const C &clause,
+    const parser::ScalarIntExpr &i) {
+  if (const auto v{GetIntValue(i)}) {
+    if (*v <= 0) {
+      context_.Say(GetContext().clauseSource,
+          "The parameter of the %s clause must be "
+          "a positive integer expression"_err_en_US,
+          parser::ToUpperCaseLetters(getClauseName(clause).str()));
+    }
+  }
+}
+
+} // namespace Fortran::semantics
+
+#endif // FORTRAN_SEMANTICS_CHECK_DIRECTIVE_STRUCTURE_H_

flang/lib/Semantics/check-omp-structure.h

 //===-- lib/Semantics/check-omp-structure.h ---------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // OpenMP structure validity check list
 //    1. invalid clauses on directive
 //    2. invalid repeated clauses on directive
 //    3. TODO: invalid nesting of regions
 
 #ifndef FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_
 #define FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_
 
+#include "check-directive-structure.h"
 #include "flang/Common/enum-set.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/semantics.h"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 
-#include <unordered_map>
-
 using OmpDirectiveSet = Fortran::common::EnumSet<llvm::omp::Directive,
     llvm::omp::Directive_enumSize>;
 
 using OmpClauseSet =
     Fortran::common::EnumSet<llvm::omp::Clause, llvm::omp::Clause_enumSize>;
 
 #define GEN_FLANG_DIRECTIVE_CLAUSE_SETS
 #include "llvm/Frontend/OpenMP/OMP.cpp.inc"
static OmpDirectiveSet simdSet{Directive::OMPD_distribute_parallel_do_simd,
     Directive::OMPD_teams_distribute_simd};
 static OmpDirectiveSet taskGeneratingSet{
     OmpDirectiveSet{Directive::OMPD_task} | taskloopSet};
 } // namespace omp
 } // namespace llvm
 
 namespace Fortran::semantics {
 
-class OmpStructureChecker : public virtual BaseChecker {
+class OmpStructureChecker
+    : public DirectiveStructureChecker<llvm::omp::Directive, llvm::omp::Clause,
+          parser::OmpClause, llvm::omp::Clause_enumSize> {
 public:
-  OmpStructureChecker(SemanticsContext &context) : context_{context} {}
+  OmpStructureChecker(SemanticsContext &context)
+      : DirectiveStructureChecker(context,
+#define GEN_FLANG_DIRECTIVE_CLAUSE_MAP
+#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
+        ) {
+  }
 
   void Enter(const parser::OpenMPConstruct &);
   void Enter(const parser::OpenMPLoopConstruct &);
   void Leave(const parser::OpenMPLoopConstruct &);
   void Enter(const parser::OmpEndLoopDirective &);
 
   void Enter(const parser::OpenMPBlockConstruct &);
   void Leave(const parser::OpenMPBlockConstruct &);
#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
   void Enter(const parser::OmpIfClause &);
   void Enter(const parser::OmpLinearClause &);
   void Enter(const parser::OmpMapClause &);
   void Enter(const parser::OmpProcBindClause &);
   void Enter(const parser::OmpReductionClause &);
   void Enter(const parser::OmpScheduleClause &);
 
 private:
-#define GEN_FLANG_DIRECTIVE_CLAUSE_MAP
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
-
-  struct OmpContext {
-    OmpContext(parser::CharBlock source, llvm::omp::Directive d)
-        : directiveSource{source}, directive{d} {}
-    parser::CharBlock directiveSource{nullptr};
-    parser::CharBlock clauseSource{nullptr};
-    llvm::omp::Directive directive;
-    OmpClauseSet allowedClauses{};
-    OmpClauseSet allowedOnceClauses{};
-    OmpClauseSet allowedExclusiveClauses{};
-    OmpClauseSet requiredClauses{};
-
-    const parser::OmpClause *clause{nullptr};
-    std::multimap<llvm::omp::Clause, const parser::OmpClause *> clauseInfo;
-  };
-  // back() is the top of the stack
-  OmpContext &GetContext() {
-    CHECK(!ompContext_.empty());
-    return ompContext_.back();
-  }
-  // reset source location, check information, and
-  // collected information for END directive
-  void ResetPartialContext(const parser::CharBlock &source) {
-    CHECK(!ompContext_.empty());
-    SetContextDirectiveSource(source);
-    GetContext().allowedClauses = {};
-    GetContext().allowedOnceClauses = {};
-    GetContext().allowedExclusiveClauses = {};
-    GetContext().requiredClauses = {};
-    GetContext().clauseInfo = {};
-  }
-  void SetContextDirectiveSource(const parser::CharBlock &directive) {
-    GetContext().directiveSource = directive;
-  }
-  void SetContextClause(const parser::OmpClause &clause) {
-    GetContext().clauseSource = clause.source;
-    GetContext().clause = &clause;
-  }
-  void SetContextDirectiveEnum(llvm::omp::Directive dir) {
-    GetContext().directive = dir;
-  }
-  void SetContextAllowed(const OmpClauseSet &allowed) {
-    GetContext().allowedClauses = allowed;
-  }
-  void SetContextAllowedOnce(const OmpClauseSet &allowedOnce) {
-    GetContext().allowedOnceClauses = allowedOnce;
-  }
-  void SetContextAllowedExclusive(const OmpClauseSet &allowedExclusive) {
-    GetContext().allowedExclusiveClauses = allowedExclusive;
-  }
-  void SetContextRequired(const OmpClauseSet &required) {
-    GetContext().requiredClauses = required;
-  }
-  void SetContextClauseInfo(llvm::omp::Clause type) {
-    GetContext().clauseInfo.emplace(type, GetContext().clause);
-  }
-  const parser::OmpClause *FindClause(llvm::omp::Clause type) {
-    auto it{GetContext().clauseInfo.find(type)};
-    if (it != GetContext().clauseInfo.end()) {
-      return it->second;
-    }
-    return nullptr;
-  }
-  void PushContext(const parser::CharBlock &source, llvm::omp::Directive dir) {
-    ompContext_.emplace_back(source, dir);
-  }
-  void SetClauseSets(llvm::omp::Directive dir) {
-    ompContext_.back().allowedClauses = directiveClausesTable[dir].allowed;
-    ompContext_.back().allowedOnceClauses =
-        directiveClausesTable[dir].allowedOnce;
-    ompContext_.back().allowedExclusiveClauses =
-        directiveClausesTable[dir].allowedExclusive;
-    ompContext_.back().requiredClauses =
-        directiveClausesTable[dir].requiredOneOf;
-  }
-  void PushContextAndClauseSets(
-      const parser::CharBlock &source, llvm::omp::Directive dir) {
-    PushContext(source, dir);
-    SetClauseSets(dir);
-  }
-  void RequiresConstantPositiveParameter(
-      const llvm::omp::Clause &clause, const parser::ScalarIntConstantExpr &i);
-  void RequiresPositiveParameter(
-      const llvm::omp::Clause &clause, const parser::ScalarIntExpr &i);
 
-  bool CurrentDirectiveIsNested() { return ompContext_.size() > 0; };
   bool HasInvalidWorksharingNesting(
       const parser::CharBlock &, const OmpDirectiveSet &);
-  void CheckAllowed(llvm::omp::Clause);
-  void CheckRequired(llvm::omp::Clause);
-  std::string ContextDirectiveAsFortran();
-  void SayNotMatching(const parser::CharBlock &, const parser::CharBlock &);
-  template <typename A, typename B, typename C>
-  const A &CheckMatching(const B &beginDir, const C &endDir) {
-    const A &begin{std::get<A>(beginDir.t)};
-    const A &end{std::get<A>(endDir.t)};
-    if (begin.v != end.v) {
-      SayNotMatching(begin.source, end.source);
-    }
-    return begin;
-  }
 
   // specific clause related
   bool ScheduleModifierHasType(const parser::OmpScheduleClause &,
       const parser::OmpScheduleModifierType::ModType &);
 
-  SemanticsContext &context_;
-  std::vector<OmpContext> ompContext_; // used as a stack
+  llvm::StringRef getClauseName(llvm::omp::Clause clause) override;
+  llvm::StringRef getDirectiveName(llvm::omp::Directive directive) override;
 };
 } // namespace Fortran::semantics
 #endif // FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_

flang/lib/Semantics/check-omp-structure.cpp

 //===-- lib/Semantics/check-omp-structure.cpp -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "check-omp-structure.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/tools.h"
 
 namespace Fortran::semantics {
 
-std::string OmpStructureChecker::ContextDirectiveAsFortran() {
-  auto dir = llvm::omp::getOpenMPDirectiveName(GetContext().directive).str();
-  std::transform(dir.begin(), dir.end(), dir.begin(),
-      [](unsigned char c) { return std::toupper(c); });
-  return dir;
-}
-
-void OmpStructureChecker::SayNotMatching(
-    const parser::CharBlock &beginSource, const parser::CharBlock &endSource) {
-  context_
-      .Say(endSource, "Unmatched %s directive"_err_en_US,
-          parser::ToUpperCaseLetters(endSource.ToString()))
-      .Attach(beginSource, "Does not match directive"_en_US);
-}
-
 bool OmpStructureChecker::HasInvalidWorksharingNesting(
     const parser::CharBlock &source, const OmpDirectiveSet &set) {
   // set contains all the invalid closely nested directives
   // for the given directive (`source` here)
   if (CurrentDirectiveIsNested() && set.test(GetContext().directive)) {
     context_.Say(source,
         "A worksharing region may not be closely nested inside a "
         "worksharing, explicit task, taskloop, critical, ordered, atomic, or "
         "master region"_err_en_US);
     return true;
   }
   return false;
 }
 
-void OmpStructureChecker::CheckAllowed(llvm::omp::Clause type) {
-  if (!GetContext().allowedClauses.test(type) &&
-      !GetContext().allowedOnceClauses.test(type) &&
-      !GetContext().allowedExclusiveClauses.test(type) &&
-      !GetContext().requiredClauses.test(type)) {
-    context_.Say(GetContext().clauseSource,
-        "%s clause is not allowed on the %s directive"_err_en_US,
-        parser::ToUpperCaseLetters(llvm::omp::getOpenMPClauseName(type).str()),
-        parser::ToUpperCaseLetters(GetContext().directiveSource.ToString()));
-    return;
-  }
-  if ((GetContext().allowedOnceClauses.test(type) ||
-          GetContext().allowedExclusiveClauses.test(type)) &&
-      FindClause(type)) {
-    context_.Say(GetContext().clauseSource,
-        "At most one %s clause can appear on the %s directive"_err_en_US,
-        parser::ToUpperCaseLetters(llvm::omp::getOpenMPClauseName(type).str()),
-        parser::ToUpperCaseLetters(GetContext().directiveSource.ToString()));
-    return;
-  }
-  if (GetContext().allowedExclusiveClauses.test(type)) {
-    std::vector<llvm::omp::Clause> others;
-    GetContext().allowedExclusiveClauses.IterateOverMembers(
-        [&](llvm::omp::Clause o) {
-          if (FindClause(o)) {
-            others.emplace_back(o);
-          }
-        });
-    for (const auto &e : others) {
-      context_.Say(GetContext().clauseSource,
-          "%s and %s are mutually exclusive and may not appear on the "
-          "same %s directive"_err_en_US,
-          parser::ToUpperCaseLetters(
-              llvm::omp::getOpenMPClauseName(type).str()),
-          parser::ToUpperCaseLetters(llvm::omp::getOpenMPClauseName(e).str()),
-          parser::ToUpperCaseLetters(GetContext().directiveSource.ToString()));
-    }
-    if (!others.empty()) {
-      return;
-    }
-  }
-  SetContextClauseInfo(type);
-}
-
-void OmpStructureChecker::CheckRequired(llvm::omp::Clause c) {
-  if (!FindClause(c)) {
-    context_.Say(GetContext().directiveSource,
-        "At least one %s clause must appear on the %s directive"_err_en_US,
-        parser::ToUpperCaseLetters(llvm::omp::getOpenMPClauseName(c).str()),
-        ContextDirectiveAsFortran());
-  }
-}
-
-void OmpStructureChecker::RequiresConstantPositiveParameter(
-    const llvm::omp::Clause &clause, const parser::ScalarIntConstantExpr &i) {
-  if (const auto v{GetIntValue(i)}) {
-    if (*v <= 0) {
-      context_.Say(GetContext().clauseSource,
-          "The parameter of the %s clause must be "
-          "a constant positive integer expression"_err_en_US,
-          parser::ToUpperCaseLetters(
-              llvm::omp::getOpenMPClauseName(clause).str()));
-    }
-  }
-}
-
-void OmpStructureChecker::RequiresPositiveParameter(
-    const llvm::omp::Clause &clause, const parser::ScalarIntExpr &i) {
-  if (const auto v{GetIntValue(i)}) {
-    if (*v <= 0) {
-      context_.Say(GetContext().clauseSource,
-          "The parameter of the %s clause must be "
-          "a positive integer expression"_err_en_US,
-          parser::ToUpperCaseLetters(
-              llvm::omp::getOpenMPClauseName(clause).str()));
-    }
-  }
-}
-
 void OmpStructureChecker::Enter(const parser::OpenMPConstruct &) {
   // 2.8.1 TODO: Simd Construct with Ordered Construct Nesting check
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPLoopConstruct &x) {
   const auto &beginLoopDir{std::get<parser::OmpBeginLoopDirective>(x.t)};
   const auto &beginDir{std::get<parser::OmpLoopDirective>(beginLoopDir.t)};
 
   // check matching, End directive is optional
   if (const auto &endLoopDir{
           std::get<std::optional<parser::OmpEndLoopDirective>>(x.t)}) {
-    CheckMatching<parser::OmpLoopDirective>(beginLoopDir, *endLoopDir);
+    const auto &endDir{
+        std::get<parser::OmpLoopDirective>(endLoopDir.value().t)};
+
+    CheckMatching<parser::OmpLoopDirective>(beginDir, endDir);
   }
 
   if (beginDir.v != llvm::omp::Directive::OMPD_do) {
     PushContextAndClauseSets(beginDir.source, beginDir.v);
   } else {
     // 2.7.1 do-clause -> private-clause |
     //                    firstprivate-clause |
     //                    lastprivate-clause |
HasInvalidWorksharingNesting(beginDir.source,
             llvm::omp::Directive::OMPD_ordered,
             llvm::omp::Directive::OMPD_atomic,
             llvm::omp::Directive::OMPD_master});
     PushContextAndClauseSets(beginDir.source, llvm::omp::Directive::OMPD_do);
   }
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPLoopConstruct &) {
-  ompContext_.pop_back();
+  dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OmpEndLoopDirective &x) {
   const auto &dir{std::get<parser::OmpLoopDirective>(x.t)};
   ResetPartialContext(dir.source);
   switch (dir.v) {
   // 2.7.1 end-do -> END DO [nowait-clause]
   // 2.8.3 end-do-simd -> END DO SIMD [nowait-clause]
   case llvm::omp::Directive::OMPD_do:
   case llvm::omp::Directive::OMPD_do_simd:
     SetClauseSets(dir.v);
     break;
   default:
     // no clauses are allowed
     break;
   }
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPBlockConstruct &x) {
   const auto &beginBlockDir{std::get<parser::OmpBeginBlockDirective>(x.t)};
   const auto &endBlockDir{std::get<parser::OmpEndBlockDirective>(x.t)};
-  const auto &beginDir{
-      CheckMatching<parser::OmpBlockDirective>(beginBlockDir, endBlockDir)};
+  const auto &beginDir{std::get<parser::OmpBlockDirective>(beginBlockDir.t)};
+  const auto &endDir{std::get<parser::OmpBlockDirective>(endBlockDir.t)};
+  CheckMatching<parser::OmpBlockDirective>(beginDir, endDir);
 
   PushContextAndClauseSets(beginDir.source, beginDir.v);
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPBlockConstruct &) {
-  ompContext_.pop_back();
+  dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPSectionsConstruct &x) {
   const auto &beginSectionsDir{
       std::get<parser::OmpBeginSectionsDirective>(x.t)};
   const auto &endSectionsDir{std::get<parser::OmpEndSectionsDirective>(x.t)};
-  const auto &beginDir{CheckMatching<parser::OmpSectionsDirective>(
-      beginSectionsDir, endSectionsDir)};
+  const auto &beginDir{
+      std::get<parser::OmpSectionsDirective>(beginSectionsDir.t)};
+  const auto &endDir{std::get<parser::OmpSectionsDirective>(endSectionsDir.t)};
+  CheckMatching<parser::OmpSectionsDirective>(beginDir, endDir);
 
   PushContextAndClauseSets(beginDir.source, beginDir.v);
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPSectionsConstruct &) {
-  ompContext_.pop_back();
+  dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OmpEndSectionsDirective &x) {
   const auto &dir{std::get<parser::OmpSectionsDirective>(x.t)};
   ResetPartialContext(dir.source);
   switch (dir.v) {
     // 2.7.2 end-sections -> END SECTIONS [nowait-clause]
   case llvm::omp::Directive::OMPD_sections:
     SetContextDirectiveEnum(llvm::omp::Directive::OMPD_end_sections);
     SetContextAllowed(OmpClauseSet{llvm::omp::Clause::OMPC_nowait});
     break;
   default:
     // no clauses are allowed
     break;
   }
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPDeclareSimdConstruct &x) {
   const auto &dir{std::get<parser::Verbatim>(x.t)};
   PushContextAndClauseSets(dir.source, llvm::omp::Directive::OMPD_declare_simd);
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPDeclareSimdConstruct &) {
-  ompContext_.pop_back();
+  dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPDeclareTargetConstruct &x) {
   const auto &dir{std::get<parser::Verbatim>(x.t)};
   PushContext(dir.source, llvm::omp::Directive::OMPD_declare_target);
   const auto &spec{std::get<parser::OmpDeclareTargetSpecifier>(x.t)};
   if (std::holds_alternative<parser::OmpDeclareTargetWithClause>(spec.u)) {
     SetContextAllowed(
         OmpClauseSet{llvm::omp::Clause::OMPC_to, llvm::omp::Clause::OMPC_link});
   }
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPDeclareTargetConstruct &) {
-  ompContext_.pop_back();
+  dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(
     const parser::OpenMPSimpleStandaloneConstruct &x) {
   const auto &dir{std::get<parser::OmpSimpleStandaloneDirective>(x.t)};
   PushContextAndClauseSets(dir.source, dir.v);
 }
 
 void OmpStructureChecker::Leave(
     const parser::OpenMPSimpleStandaloneConstruct &) {
-  ompContext_.pop_back();
+  dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPFlushConstruct &x) {
   const auto &dir{std::get<parser::Verbatim>(x.t)};
   PushContextAndClauseSets(dir.source, llvm::omp::Directive::OMPD_flush);
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPFlushConstruct &) {
-  ompContext_.pop_back();
+  dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPCancelConstruct &x) {
   const auto &dir{std::get<parser::Verbatim>(x.t)};
   PushContextAndClauseSets(dir.source, llvm::omp::Directive::OMPD_cancel);
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPCancelConstruct &) {
-  ompContext_.pop_back();
+  dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(
     const parser::OpenMPCancellationPointConstruct &x) {
   const auto &dir{std::get<parser::Verbatim>(x.t)};
   PushContextAndClauseSets(
       dir.source, llvm::omp::Directive::OMPD_cancellation_point);
 }
 
 void OmpStructureChecker::Leave(
     const parser::OpenMPCancellationPointConstruct &) {
-  ompContext_.pop_back();
+  dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OmpEndBlockDirective &x) {
   const auto &dir{std::get<parser::OmpBlockDirective>(x.t)};
   ResetPartialContext(dir.source);
   switch (dir.v) {
   // 2.7.3 end-single-clause -> copyprivate-clause |
   //                            nowait-clause
if (ScheduleModifierHasType(
           kind != parser::OmpScheduleClause::ScheduleType::Guided) {
         context_.Say(GetContext().clauseSource,
             "The NONMONOTONIC modifier can only be specified with "
             "SCHEDULE(DYNAMIC) or SCHEDULE(GUIDED)"_err_en_US);
       }
     }
   }
 }
+
+llvm::StringRef OmpStructureChecker::getClauseName(llvm::omp::Clause clause) {
+  return llvm::omp::getOpenMPClauseName(clause);
+}
+
+llvm::StringRef OmpStructureChecker::getDirectiveName(
+    llvm::omp::Directive directive) {
+  return llvm::omp::getOpenMPDirectiveName(directive);
+}
+
 } // namespace Fortran::semantics

flang/test/Semantics/acc-clause-validity.f90

program openacc_clause_validity
   !$acc parallel device_type(*) num_gangs(2)
   !$acc loop
   do i = 1, N
     a(i) = 3.14
   end do
   !$acc end parallel
 
   !$acc parallel
-  !ERROR: The parameter of the COLLAPSE clause on the LOOP directive must be a constant positive integer expression
+  !ERROR: The parameter of the COLLAPSE clause must be a constant positive integer expression
   !$acc loop collapse(-1)
   do i = 1, N
     do j = 1, N
       a(i) = 3.14 + j
     end do
   end do
   !$acc end parallel
 

flang/test/Semantics/omp-clause-validity01.f90

!                          nogroup-clause
   enddo
 
   !ERROR: SCHEDULE clause is not allowed on the TASKLOOP directive
   !$omp taskloop schedule(static)
   do i = 1, N
      a = 3.14
   enddo
 
-  !ERROR: GRAINSIZE and NUM_TASKS are mutually exclusive and may not appear on the same TASKLOOP directive
+  !ERROR: GRAINSIZE and NUM_TASKS clauses are mutually exclusive and may not appear on the same TASKLOOP directive
   !$omp taskloop num_tasks(3) grainsize(2)
   do i = 1,N
      a = 3.14
   enddo
 
   !ERROR: At most one NUM_TASKS clause can appear on the TASKLOOP directive
   !$omp taskloop num_tasks(3) num_tasks(2)
   do i = 1,N
!                               simd-clause
 
   !$omp taskloop simd reduction(+:a)
   do i = 1, N
      a = a + 3.14
   enddo
   !ERROR: Unmatched END TASKLOOP directive
   !$omp end taskloop
 
-  !ERROR: GRAINSIZE and NUM_TASKS are mutually exclusive and may not appear on the same TASKLOOP SIMD directive
+  !ERROR: GRAINSIZE and NUM_TASKS clauses are mutually exclusive and may not appear on the same TASKLOOP SIMD directive
   !$omp taskloop simd num_tasks(3) grainsize(2)
   do i = 1,N
      a = 3.14
   enddo
 
   !ERROR: The parameter of the SIMDLEN clause must be a constant positive integer expression
   !ERROR: The ALIGNMENT parameter of the ALIGNED clause must be a constant positive integer expression
   !ERROR: Internal: no symbol found for 'a'
   !$omp taskloop simd simdlen(-1) aligned(a:-2)
   do i = 1, N
      a = 3.14
   enddo
 end program

flang/test/Semantics/omp-declarative-directive.f90

abstract interface
      end subroutine sub
   end interface
 end module m1
 
 subroutine declare_simd_2
   use m1
   procedure (sub) sub1
   !ERROR: Internal: no symbol found for 'sub1'
-  !ERROR: NOTINBRANCH and INBRANCH are mutually exclusive and may not appear on the same DECLARE SIMD directive
+  !ERROR: NOTINBRANCH and INBRANCH clauses are mutually exclusive and may not appear on the same DECLARE SIMD directive
   !$omp declare simd(sub1) inbranch notinbranch
   procedure (sub), pointer::p
   p=>sub1
   call p(5,10)
 end subroutine declare_simd_2
 
 subroutine sub1 (x,y)
   integer, intent(in)::x, y

llvm/test/TableGen/directive1.td

 // GEN-NEXT:  } // namespace tdl
 // GEN-NEXT:  } // namespace llvm
 // GEN-EMPTY:
 // GEN-NEXT:  #endif // GEN_FLANG_DIRECTIVE_CLAUSE_SETS
 // GEN-EMPTY:
 // GEN-NEXT:  #ifdef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
 // GEN-NEXT:  #undef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
 // GEN-EMPTY:
-// GEN-NEXT:  struct TdlDirectiveClauses {
-// GEN-NEXT:    const  allowed;
-// GEN-NEXT:    const  allowedOnce;
-// GEN-NEXT:    const  allowedExclusive;
-// GEN-NEXT:    const  requiredOneOf;
-// GEN-NEXT:  };
-// GEN-EMPTY:
-// GEN-NEXT:  std::unordered_map<llvm::tdl::Directive, TdlDirectiveClauses>
-// GEN-NEXT:      directiveClausesTable = {
+// GEN-NEXT:  {
 // GEN-NEXT:    {llvm::tdl::Directive::TDLD_dira,
 // GEN-NEXT:      {
 // GEN-NEXT:        llvm::tdl::allowedClauses_TDLD_dira,
 // GEN-NEXT:        llvm::tdl::allowedOnceClauses_TDLD_dira,
 // GEN-NEXT:        llvm::tdl::allowedExclusiveClauses_TDLD_dira,
 // GEN-NEXT:        llvm::tdl::requiredClauses_TDLD_dira,
 // GEN-NEXT:      }
 // GEN-NEXT:    },
-// GEN-NEXT:  };
+// GEN-NEXT:  }
 // GEN-EMPTY:
 // GEN-NEXT:  #endif // GEN_FLANG_DIRECTIVE_CLAUSE_MAP
 

llvm/test/TableGen/directive2.td

 // GEN-NEXT: } // namespace tdl
 // GEN-NEXT: } // namespace llvm
 // GEN-EMPTY:
 // GEN-NEXT: #endif // GEN_FLANG_DIRECTIVE_CLAUSE_SETS
 // GEN-EMPTY:
 // GEN-NEXT: #ifdef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
 // GEN-NEXT: #undef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
 // GEN-EMPTY:
-// GEN-NEXT: struct TdlDirectiveClauses {
-// GEN-NEXT:   const  allowed;
-// GEN-NEXT:   const  allowedOnce;
-// GEN-NEXT:   const  allowedExclusive;
-// GEN-NEXT:   const  requiredOneOf;
-// GEN-NEXT: };
-// GEN-EMPTY:
-// GEN-NEXT: std::unordered_map<llvm::tdl::Directive, TdlDirectiveClauses>
-// GEN-NEXT:     directiveClausesTable = {
+// GEN-NEXT: {
 // GEN-NEXT:   {llvm::tdl::Directive::TDLD_dira,
 // GEN-NEXT:     {
 // GEN-NEXT:       llvm::tdl::allowedClauses_TDLD_dira,
 // GEN-NEXT:       llvm::tdl::allowedOnceClauses_TDLD_dira,
 // GEN-NEXT:       llvm::tdl::allowedExclusiveClauses_TDLD_dira,
 // GEN-NEXT:       llvm::tdl::requiredClauses_TDLD_dira,
 // GEN-NEXT:     }
 // GEN-NEXT:   },
-// GEN-NEXT: };
+// GEN-NEXT: }
 // GEN-EMPTY:
 // GEN-NEXT: #endif // GEN_FLANG_DIRECTIVE_CLAUSE_MAP

llvm/utils/TableGen/DirectiveEmitter.cpp

 // The struct holds the 4 sets of enumeration for the 4 kinds of clauses
 // allowances (allowed, allowed once, allowed exclusive and required).
 void GenerateDirectiveClauseMap(const std::vector<Record *> &Directives,
                                 raw_ostream &OS, DirectiveLanguage &DirLang) {
 
   IfDefScope Scope("GEN_FLANG_DIRECTIVE_CLAUSE_MAP", OS);
 
   OS << "\n";
-  OS << "struct " << DirLang.getName() << "DirectiveClauses {\n";
-  OS << "  const " << DirLang.getClauseEnumSetClass() << " allowed;\n";
-  OS << "  const " << DirLang.getClauseEnumSetClass() << " allowedOnce;\n";
-  OS << "  const " << DirLang.getClauseEnumSetClass() << " allowedExclusive;\n";
-  OS << "  const " << DirLang.getClauseEnumSetClass() << " requiredOneOf;\n";
-  OS << "};\n";
-
-  OS << "\n";
-
-  OS << "std::unordered_map<llvm::" << DirLang.getCppNamespace()
-     << "::Directive, " << DirLang.getName() << "DirectiveClauses>\n";
-  OS << "    directiveClausesTable = {\n";
+  OS << "{\n";
 
   for (const auto &D : Directives) {
     Directive Dir{D};
     OS << "  {llvm::" << DirLang.getCppNamespace()
        << "::Directive::" << DirLang.getDirectivePrefix()
        << Dir.getFormattedName() << ",\n";
     OS << "    {\n";
     OS << "      llvm::" << DirLang.getCppNamespace() << "::allowedClauses_"
        << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n";
     OS << "      llvm::" << DirLang.getCppNamespace() << "::allowedOnceClauses_"
        << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n";
     OS << "      llvm::" << DirLang.getCppNamespace()
        << "::allowedExclusiveClauses_" << DirLang.getDirectivePrefix()
        << Dir.getFormattedName() << ",\n";
     OS << "      llvm::" << DirLang.getCppNamespace() << "::requiredClauses_"
        << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n";
     OS << "    }\n";
     OS << "  },\n";
   }
 
-  OS << "};\n";
+  OS << "}\n";
 }
 
 // Generate the implemenation section for the enumeration in the directive
 // language
 void EmitDirectivesFlangImpl(const std::vector<Record *> &Directives,
                              raw_ostream &OS,
                              DirectiveLanguage &DirectiveLanguage) {