Revert "Revert "[Flang][Sema] Move directive sets to a shared location""

[skatrak]

Summary

This reverts commit f48969f90769f37e042025dba6c544eeddd6d3e6.

[kiranchandramohan]

LG. Please wait for the CI to pass.

clang/docs/tools/clang-formatted-files.txt

 flang/include/flang/Runtime/random.h
 flang/include/flang/Runtime/reduction.h
 flang/include/flang/Runtime/stop.h
 flang/include/flang/Runtime/support.h
 flang/include/flang/Runtime/time-intrinsic.h
 flang/include/flang/Runtime/transformational.h
 flang/include/flang/Runtime/type-code.h
 flang/include/flang/Semantics/attr.h
+flang/include/flang/Semantics/expression.h
+flang/include/flang/Semantics/openmp-directive-sets.h
 flang/include/flang/Semantics/runtime-type-info.h
 flang/include/flang/Semantics/scope.h
 flang/include/flang/Semantics/semantics.h
 flang/include/flang/Semantics/symbol.h
 flang/include/flang/Semantics/tools.h
 flang/include/flang/Semantics/type.h
 flang/include/flang/Semantics/unparse-with-symbols.h
 flang/lib/Common/default-kinds.cpp

flang/include/flang/Semantics/openmp-directive-sets.h

+//===-- include/flang/Semantics/openmp-directive-sets.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_SEMANTICS_OPENMP_DIRECTIVE_SETS_H_
+#define FORTRAN_SEMANTICS_OPENMP_DIRECTIVE_SETS_H_
+
+#include "flang/Common/enum-set.h"
+#include "llvm/Frontend/OpenMP/OMPConstants.h"
+
+using OmpDirectiveSet = Fortran::common::EnumSet<llvm::omp::Directive,
+    llvm::omp::Directive_enumSize>;
+
+namespace llvm::omp {
+//===----------------------------------------------------------------------===//
+// Directive sets for single directives
+//===----------------------------------------------------------------------===//
+// - top<Directive>Set: The directive appears alone or as the first in a
+//   combined construct.
+// - all<Directive>Set: All standalone or combined uses of the directive.
+
+static const OmpDirectiveSet topParallelSet{
+    Directive::OMPD_parallel,
+    Directive::OMPD_parallel_do,
+    Directive::OMPD_parallel_do_simd,
+    Directive::OMPD_parallel_sections,
+    Directive::OMPD_parallel_workshare,
+};
+
+static const OmpDirectiveSet allParallelSet{
+    Directive::OMPD_distribute_parallel_do,
+    Directive::OMPD_distribute_parallel_do_simd,
+    Directive::OMPD_parallel,
+    Directive::OMPD_parallel_do,
+    Directive::OMPD_parallel_do_simd,
+    Directive::OMPD_parallel_sections,
+    Directive::OMPD_parallel_workshare,
+    Directive::OMPD_target_parallel,
+    Directive::OMPD_target_parallel_do,
+    Directive::OMPD_target_parallel_do_simd,
+    Directive::OMPD_target_teams_distribute_parallel_do,
+    Directive::OMPD_target_teams_distribute_parallel_do_simd,
+    Directive::OMPD_teams_distribute_parallel_do,
+    Directive::OMPD_teams_distribute_parallel_do_simd,
+};
+
+static const OmpDirectiveSet topDoSet{
+    Directive::OMPD_do,
+    Directive::OMPD_do_simd,
+};
+
+static const OmpDirectiveSet allDoSet{
+    Directive::OMPD_distribute_parallel_do,
+    Directive::OMPD_distribute_parallel_do_simd,
+    Directive::OMPD_parallel_do,
+    Directive::OMPD_parallel_do_simd,
+    Directive::OMPD_do,
+    Directive::OMPD_do_simd,
+    Directive::OMPD_target_parallel_do,
+    Directive::OMPD_target_parallel_do_simd,
+    Directive::OMPD_target_teams_distribute_parallel_do,
+    Directive::OMPD_target_teams_distribute_parallel_do_simd,
+    Directive::OMPD_teams_distribute_parallel_do,
+    Directive::OMPD_teams_distribute_parallel_do_simd,
+};
+
+static const OmpDirectiveSet topTaskloopSet{
+    Directive::OMPD_taskloop,
+    Directive::OMPD_taskloop_simd,
+};
+
+static const OmpDirectiveSet allTaskloopSet{topTaskloopSet};
+
+static const OmpDirectiveSet topTargetSet{
+    Directive::OMPD_target,
+    Directive::OMPD_target_parallel,
+    Directive::OMPD_target_parallel_do,
+    Directive::OMPD_target_parallel_do_simd,
+    Directive::OMPD_target_simd,
+    Directive::OMPD_target_teams,
+    Directive::OMPD_target_teams_distribute,
+    Directive::OMPD_target_teams_distribute_parallel_do,
+    Directive::OMPD_target_teams_distribute_parallel_do_simd,
+    Directive::OMPD_target_teams_distribute_simd,
+};
+
+static const OmpDirectiveSet allTargetSet{topTargetSet};
+
+static const OmpDirectiveSet topSimdSet{
+    Directive::OMPD_simd,
+};
+
+static const OmpDirectiveSet allSimdSet{
+    Directive::OMPD_distribute_parallel_do_simd,
+    Directive::OMPD_distribute_simd,
+    Directive::OMPD_do_simd,
+    Directive::OMPD_parallel_do_simd,
+    Directive::OMPD_simd,
+    Directive::OMPD_target_parallel_do_simd,
+    Directive::OMPD_target_simd,
+    Directive::OMPD_target_teams_distribute_parallel_do_simd,
+    Directive::OMPD_target_teams_distribute_simd,
+    Directive::OMPD_taskloop_simd,
+    Directive::OMPD_teams_distribute_parallel_do_simd,
+    Directive::OMPD_teams_distribute_simd,
+};
+
+static const OmpDirectiveSet topTeamsSet{
+    Directive::OMPD_teams,
+    Directive::OMPD_teams_distribute,
+    Directive::OMPD_teams_distribute_parallel_do,
+    Directive::OMPD_teams_distribute_parallel_do_simd,
+    Directive::OMPD_teams_distribute_simd,
+};
+
+static const OmpDirectiveSet allTeamsSet{
+    llvm::omp::OMPD_target_teams,
+    llvm::omp::OMPD_target_teams_distribute,
+    llvm::omp::OMPD_target_teams_distribute_parallel_do,
+    llvm::omp::OMPD_target_teams_distribute_parallel_do_simd,
+    llvm::omp::OMPD_target_teams_distribute_simd,
+    llvm::omp::OMPD_teams,
+    llvm::omp::OMPD_teams_distribute,
+    llvm::omp::OMPD_teams_distribute_parallel_do,
+    llvm::omp::OMPD_teams_distribute_parallel_do_simd,
+    llvm::omp::OMPD_teams_distribute_simd,
+};
+
+static const OmpDirectiveSet topDistributeSet{
+    Directive::OMPD_distribute,
+    Directive::OMPD_distribute_parallel_do,
+    Directive::OMPD_distribute_parallel_do_simd,
+    Directive::OMPD_distribute_simd,
+};
+
+static const OmpDirectiveSet allDistributeSet{
+    llvm::omp::OMPD_distribute,
+    llvm::omp::OMPD_distribute_parallel_do,
+    llvm::omp::OMPD_distribute_parallel_do_simd,
+    llvm::omp::OMPD_distribute_simd,
+    llvm::omp::OMPD_target_teams_distribute,
+    llvm::omp::OMPD_target_teams_distribute_parallel_do,
+    llvm::omp::OMPD_target_teams_distribute_parallel_do_simd,
+    llvm::omp::OMPD_target_teams_distribute_simd,
+    llvm::omp::OMPD_teams_distribute,
+    llvm::omp::OMPD_teams_distribute_parallel_do,
+    llvm::omp::OMPD_teams_distribute_parallel_do_simd,
+    llvm::omp::OMPD_teams_distribute_simd,
+};
+
+//===----------------------------------------------------------------------===//
+// Directive sets for groups of multiple directives
+//===----------------------------------------------------------------------===//
+
+static const OmpDirectiveSet allDoSimdSet{allDoSet & allSimdSet};
+
+static const OmpDirectiveSet workShareSet{
+    OmpDirectiveSet{
+        Directive::OMPD_workshare,
+        Directive::OMPD_parallel_workshare,
+        Directive::OMPD_parallel_sections,
+        Directive::OMPD_sections,
+        Directive::OMPD_single,
+    } | allDoSet,
+};
+
+static const OmpDirectiveSet taskGeneratingSet{
+    OmpDirectiveSet{
+        Directive::OMPD_task,
+    } | allTaskloopSet,
+};
+
+static const OmpDirectiveSet nonPartialVarSet{
+    Directive::OMPD_allocate,
+    Directive::OMPD_allocators,
+    Directive::OMPD_threadprivate,
+    Directive::OMPD_declare_target,
+};
+
+//===----------------------------------------------------------------------===//
+// Directive sets for allowed/not allowed nested directives
+//===----------------------------------------------------------------------===//
+
+static const OmpDirectiveSet nestedOrderedErrSet{
+    Directive::OMPD_critical,
+    Directive::OMPD_ordered,
+    Directive::OMPD_atomic,
+    Directive::OMPD_task,
+    Directive::OMPD_taskloop,
+};
+
+static const OmpDirectiveSet nestedWorkshareErrSet{
+    OmpDirectiveSet{
+        Directive::OMPD_task,
+        Directive::OMPD_taskloop,
+        Directive::OMPD_critical,
+        Directive::OMPD_ordered,
+        Directive::OMPD_atomic,
+        Directive::OMPD_master,
+    } | workShareSet,
+};
+
+static const OmpDirectiveSet nestedMasterErrSet{
+    OmpDirectiveSet{
+        Directive::OMPD_atomic,
+    } | taskGeneratingSet |
+        workShareSet,
+};
+
+static const OmpDirectiveSet nestedBarrierErrSet{
+    OmpDirectiveSet{
+        Directive::OMPD_critical,
+        Directive::OMPD_ordered,
+        Directive::OMPD_atomic,
+        Directive::OMPD_master,
+    } | taskGeneratingSet |
+        workShareSet,
+};
+
+static const OmpDirectiveSet nestedTeamsAllowedSet{
+    Directive::OMPD_parallel,
+    Directive::OMPD_parallel_do,
+    Directive::OMPD_parallel_do_simd,
+    Directive::OMPD_parallel_master,
+    Directive::OMPD_parallel_master_taskloop,
+    Directive::OMPD_parallel_master_taskloop_simd,
+    Directive::OMPD_parallel_sections,
+    Directive::OMPD_parallel_workshare,
+    Directive::OMPD_distribute,
+    Directive::OMPD_distribute_parallel_do,
+    Directive::OMPD_distribute_parallel_do_simd,
+    Directive::OMPD_distribute_simd,
+};
+
+static const OmpDirectiveSet nestedOrderedParallelErrSet{
+    Directive::OMPD_parallel,
+    Directive::OMPD_target_parallel,
+    Directive::OMPD_parallel_sections,
+    Directive::OMPD_parallel_workshare,
+};
+
+static const OmpDirectiveSet nestedOrderedDoAllowedSet{
+    Directive::OMPD_do,
+    Directive::OMPD_parallel_do,
+    Directive::OMPD_target_parallel_do,
+};
+
+static const OmpDirectiveSet nestedCancelTaskgroupAllowedSet{
+    Directive::OMPD_task,
+    Directive::OMPD_taskloop,
+};
+
+static const OmpDirectiveSet nestedCancelSectionsAllowedSet{
+    Directive::OMPD_sections,
+    Directive::OMPD_parallel_sections,
+};
+
+static const OmpDirectiveSet nestedCancelDoAllowedSet{
+    Directive::OMPD_do,
+    Directive::OMPD_distribute_parallel_do,
+    Directive::OMPD_parallel_do,
+    Directive::OMPD_target_parallel_do,
+    Directive::OMPD_target_teams_distribute_parallel_do,
+    Directive::OMPD_teams_distribute_parallel_do,
+};
+
+static const OmpDirectiveSet nestedCancelParallelAllowedSet{
+    Directive::OMPD_parallel,
+    Directive::OMPD_target_parallel,
+};
+
+static const OmpDirectiveSet nestedReduceWorkshareAllowedSet{
+    Directive::OMPD_do,
+    Directive::OMPD_sections,
+    Directive::OMPD_do_simd,
+};
+} // namespace llvm::omp
+
+#endif // FORTRAN_SEMANTICS_OPENMP_DIRECTIVE_SETS_H_

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

 //    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/openmp-directive-sets.h"
 #include "flang/Semantics/semantics.h"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 
-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.inc"
 
 namespace llvm {
 namespace omp {
-static OmpDirectiveSet parallelSet{Directive::OMPD_distribute_parallel_do,
-    Directive::OMPD_distribute_parallel_do_simd, Directive::OMPD_parallel,
-    Directive::OMPD_parallel_do, Directive::OMPD_parallel_do_simd,
-    Directive::OMPD_parallel_sections, Directive::OMPD_parallel_workshare,
-    Directive::OMPD_target_parallel, Directive::OMPD_target_parallel_do,
-    Directive::OMPD_target_parallel_do_simd,
-    Directive::OMPD_target_teams_distribute_parallel_do,
-    Directive::OMPD_target_teams_distribute_parallel_do_simd,
-    Directive::OMPD_teams_distribute_parallel_do,
-    Directive::OMPD_teams_distribute_parallel_do_simd};
-static OmpDirectiveSet doSet{Directive::OMPD_distribute_parallel_do,
-    Directive::OMPD_distribute_parallel_do_simd, Directive::OMPD_parallel_do,
-    Directive::OMPD_parallel_do_simd, Directive::OMPD_do,
-    Directive::OMPD_do_simd, Directive::OMPD_target_parallel_do,
-    Directive::OMPD_target_parallel_do_simd,
-    Directive::OMPD_target_teams_distribute_parallel_do,
-    Directive::OMPD_target_teams_distribute_parallel_do_simd,
-    Directive::OMPD_teams_distribute_parallel_do,
-    Directive::OMPD_teams_distribute_parallel_do_simd};
-static OmpDirectiveSet doSimdSet{Directive::OMPD_distribute_parallel_do_simd,
-    Directive::OMPD_parallel_do_simd, Directive::OMPD_do_simd,
-    Directive::OMPD_target_parallel_do_simd,
-    Directive::OMPD_target_teams_distribute_parallel_do_simd,
-    Directive::OMPD_teams_distribute_parallel_do_simd};
-static OmpDirectiveSet workShareSet{
-    OmpDirectiveSet{Directive::OMPD_workshare,
-        Directive::OMPD_parallel_workshare, Directive::OMPD_parallel_sections,
-        Directive::OMPD_sections, Directive::OMPD_single} |
-    doSet};
-static OmpDirectiveSet taskloopSet{
-    Directive::OMPD_taskloop, Directive::OMPD_taskloop_simd};
-static OmpDirectiveSet targetSet{Directive::OMPD_target,
-    Directive::OMPD_target_parallel, Directive::OMPD_target_parallel_do,
-    Directive::OMPD_target_parallel_do_simd, Directive::OMPD_target_simd,
-    Directive::OMPD_target_teams, Directive::OMPD_target_teams_distribute,
-    Directive::OMPD_target_teams_distribute_parallel_do,
-    Directive::OMPD_target_teams_distribute_parallel_do_simd,
-    Directive::OMPD_target_teams_distribute_simd};
-static OmpDirectiveSet simdSet{Directive::OMPD_distribute_parallel_do_simd,
-    Directive::OMPD_distribute_simd, Directive::OMPD_do_simd,
-    Directive::OMPD_parallel_do_simd, Directive::OMPD_simd,
-    Directive::OMPD_target_parallel_do_simd, Directive::OMPD_target_simd,
-    Directive::OMPD_target_teams_distribute_parallel_do_simd,
-    Directive::OMPD_target_teams_distribute_simd, Directive::OMPD_taskloop_simd,
-    Directive::OMPD_teams_distribute_parallel_do_simd,
-    Directive::OMPD_teams_distribute_simd};
-static OmpDirectiveSet teamSet{Directive::OMPD_teams,
-    Directive::OMPD_teams_distribute,
-    Directive::OMPD_teams_distribute_parallel_do,
-    Directive::OMPD_teams_distribute_parallel_do_simd,
-    Directive::OMPD_teams_distribute_simd};
-static OmpDirectiveSet distributeSet{Directive::OMPD_distribute,
-    Directive::OMPD_distribute_parallel_do,
-    Directive::OMPD_distribute_parallel_do_simd,
-    Directive::OMPD_distribute_simd, Directive::OMPD_target_teams_distribute,
-    Directive::OMPD_target_teams_distribute_parallel_do,
-    Directive::OMPD_target_teams_distribute_parallel_do_simd,
-    Directive::OMPD_target_teams_distribute_simd,
-    Directive::OMPD_teams_distribute,
-    Directive::OMPD_teams_distribute_parallel_do,
-    Directive::OMPD_teams_distribute_parallel_do_simd,
-    Directive::OMPD_teams_distribute_simd};
-static OmpDirectiveSet taskGeneratingSet{
-    OmpDirectiveSet{Directive::OMPD_task} | taskloopSet};
-static OmpDirectiveSet nestedOrderedErrSet{Directive::OMPD_critical,
-    Directive::OMPD_ordered, Directive::OMPD_atomic, Directive::OMPD_task,
-    Directive::OMPD_taskloop};
-static OmpDirectiveSet nestedWorkshareErrSet{
-    OmpDirectiveSet{Directive::OMPD_task, Directive::OMPD_taskloop,
-        Directive::OMPD_critical, Directive::OMPD_ordered,
-        Directive::OMPD_atomic, Directive::OMPD_master} |
-    workShareSet};
-static OmpDirectiveSet nestedMasterErrSet{
-    OmpDirectiveSet{llvm::omp::Directive::OMPD_atomic} | taskGeneratingSet |
-    workShareSet};
-static OmpDirectiveSet nestedBarrierErrSet{
-    OmpDirectiveSet{Directive::OMPD_critical, Directive::OMPD_ordered,
-        Directive::OMPD_atomic, Directive::OMPD_master} |
-    taskGeneratingSet | workShareSet};
 static OmpClauseSet privateSet{
     Clause::OMPC_private, Clause::OMPC_firstprivate, Clause::OMPC_lastprivate};
 static OmpClauseSet privateReductionSet{
     OmpClauseSet{Clause::OMPC_reduction} | privateSet};
 } // namespace omp
 } // namespace llvm
 
 namespace Fortran::semantics {

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

bool OmpStructureChecker::IsCloselyNestedRegion(const OmpDirectiveSet &set) {
   // the entire stack, `close nesting` is not satisfied. If at any level, a
   // `parallel` region is found, `close nesting` is not satisfied.
 
   if (CurrentDirectiveIsNested()) {
     int index = dirContext_.size() - 2;
     while (index != -1) {
       if (set.test(dirContext_[index].directive)) {
         return true;
-      } else if (llvm::omp::parallelSet.test(dirContext_[index].directive)) {
+      } else if (llvm::omp::allParallelSet.test(dirContext_[index].directive)) {
         return false;
       }
       index--;
     }
   }
   return false;
 }
 
if (IsCloselyNestedRegion(set)) {
     return true;
   }
   return false;
 }
 
 void OmpStructureChecker::HasInvalidDistributeNesting(
     const parser::OpenMPLoopConstruct &x) {
   bool violation{false};
-
-  OmpDirectiveSet distributeSet{llvm::omp::Directive::OMPD_distribute,
-      llvm::omp::Directive::OMPD_distribute_parallel_do,
-      llvm::omp::Directive::OMPD_distribute_parallel_do_simd,
-      llvm::omp::Directive::OMPD_distribute_parallel_for,
-      llvm::omp::Directive::OMPD_distribute_parallel_for_simd,
-      llvm::omp::Directive::OMPD_distribute_simd};
-
   const auto &beginLoopDir{std::get<parser::OmpBeginLoopDirective>(x.t)};
   const auto &beginDir{std::get<parser::OmpLoopDirective>(beginLoopDir.t)};
-  if (distributeSet.test(beginDir.v)) {
+  if (llvm::omp::topDistributeSet.test(beginDir.v)) {
     // `distribute` region has to be nested
     if (!CurrentDirectiveIsNested()) {
       violation = true;
     } else {
       // `distribute` region has to be strictly nested inside `teams`
-      if (!llvm::omp::teamSet.test(GetContextParent().directive)) {
+      if (!llvm::omp::topTeamsSet.test(GetContextParent().directive)) {
         violation = true;
       }
     }
   }
   if (violation) {
     context_.Say(beginDir.source,
         "`DISTRIBUTE` region has to be strictly nested inside `TEAMS` "
         "region."_err_en_US);
   }
 }
 
 void OmpStructureChecker::HasInvalidTeamsNesting(
     const llvm::omp::Directive &dir, const parser::CharBlock &source) {
-  OmpDirectiveSet allowedSet{llvm::omp::Directive::OMPD_parallel,
-      llvm::omp::Directive::OMPD_parallel_do,
-      llvm::omp::Directive::OMPD_parallel_do_simd,
-      llvm::omp::Directive::OMPD_parallel_for,
-      llvm::omp::Directive::OMPD_parallel_for_simd,
-      llvm::omp::Directive::OMPD_parallel_master,
-      llvm::omp::Directive::OMPD_parallel_master_taskloop,
-      llvm::omp::Directive::OMPD_parallel_master_taskloop_simd,
-      llvm::omp::Directive::OMPD_parallel_sections,
-      llvm::omp::Directive::OMPD_parallel_workshare,
-      llvm::omp::Directive::OMPD_distribute,
-      llvm::omp::Directive::OMPD_distribute_parallel_do,
-      llvm::omp::Directive::OMPD_distribute_parallel_do_simd,
-      llvm::omp::Directive::OMPD_distribute_parallel_for,
-      llvm::omp::Directive::OMPD_distribute_parallel_for_simd,
-      llvm::omp::Directive::OMPD_distribute_simd};
-
-  if (!allowedSet.test(dir)) {
+  if (!llvm::omp::nestedTeamsAllowedSet.test(dir)) {
     context_.Say(source,
         "Only `DISTRIBUTE` or `PARALLEL` regions are allowed to be strictly "
         "nested inside `TEAMS` region."_err_en_US);
   }
 }
 
 void OmpStructureChecker::CheckPredefinedAllocatorRestriction(
     const parser::CharBlock &source, const parser::Name &name) {
if (const auto &endLoopDir{
           std::get<std::optional<parser::OmpEndLoopDirective>>(x.t)}) {
     const auto &endDir{
         std::get<parser::OmpLoopDirective>(endLoopDir.value().t)};
 
     CheckMatching<parser::OmpLoopDirective>(beginDir, endDir);
   }
 
   PushContextAndClauseSets(beginDir.source, beginDir.v);
-  if (llvm::omp::simdSet.test(GetContext().directive)) {
+  if (llvm::omp::allSimdSet.test(GetContext().directive)) {
     EnterDirectiveNest(SIMDNest);
   }
 
   if (beginDir.v == llvm::omp::Directive::OMPD_do) {
     // 2.7.1 do-clause -> private-clause |
     //                    firstprivate-clause |
     //                    lastprivate-clause |
     //                    linear-clause |
if (const auto &doConstruct{
     const auto &doBlock{std::get<parser::Block>(doConstruct->t)};
     CheckNoBranching(doBlock, beginDir.v, beginDir.source);
   }
   CheckDoWhile(x);
   CheckLoopItrVariableIsInt(x);
   CheckCycleConstraints(x);
   HasInvalidDistributeNesting(x);
   if (CurrentDirectiveIsNested() &&
-      llvm::omp::teamSet.test(GetContextParent().directive)) {
+      llvm::omp::topTeamsSet.test(GetContextParent().directive)) {
     HasInvalidTeamsNesting(beginDir.v, beginDir.source);
   }
   if ((beginDir.v == llvm::omp::Directive::OMPD_distribute_parallel_do_simd) ||
       (beginDir.v == llvm::omp::Directive::OMPD_distribute_simd)) {
     CheckDistLinear(x);
   }
 }
 const parser::Name OmpStructureChecker::GetLoopIndex(
for (auto var : indexVars) {
           "can be specified in `LINEAR` clause of a construct combined with "
           "`DISTRIBUTE`"_err_en_US,
           root.name());
     }
   }
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPLoopConstruct &) {
-  if (llvm::omp::simdSet.test(GetContext().directive)) {
+  if (llvm::omp::allSimdSet.test(GetContext().directive)) {
     ExitDirectiveNest(SIMDNest);
   }
   dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OmpEndLoopDirective &x) {
   const auto &dir{std::get<parser::OmpLoopDirective>(x.t)};
   ResetPartialContext(dir.source);
void OmpStructureChecker::Enter(const parser::OpenMPBlockConstruct &x) {
   CheckMatching<parser::OmpBlockDirective>(beginDir, endDir);
 
   PushContextAndClauseSets(beginDir.source, beginDir.v);
   if (GetContext().directive == llvm::omp::Directive::OMPD_target) {
     EnterDirectiveNest(TargetNest);
   }
 
   if (CurrentDirectiveIsNested()) {
-    if (llvm::omp::teamSet.test(GetContextParent().directive)) {
+    if (llvm::omp::topTeamsSet.test(GetContextParent().directive)) {
       HasInvalidTeamsNesting(beginDir.v, beginDir.source);
     }
     if (GetContext().directive == llvm::omp::Directive::OMPD_master) {
       CheckMasterNesting(x);
     }
     // A teams region can only be strictly nested within the implicit parallel
     // region or a target region.
     if (GetContext().directive == llvm::omp::Directive::OMPD_teams &&

 void OmpStructureChecker::ChecksOnOrderedAsBlock() {
   if (FindClause(llvm::omp::Clause::OMPC_depend)) {
     context_.Say(GetContext().clauseSource,
         "DEPEND(*) clauses are not allowed when ORDERED construct is a block"
         " construct with an ORDERED region"_err_en_US);
     return;
   }
 
-  OmpDirectiveSet notAllowedParallelSet{llvm::omp::Directive::OMPD_parallel,
-      llvm::omp::Directive::OMPD_target_parallel,
-      llvm::omp::Directive::OMPD_parallel_sections,
-      llvm::omp::Directive::OMPD_parallel_workshare};
   bool isNestedInDo{false};
   bool isNestedInDoSIMD{false};
   bool isNestedInSIMD{false};
   bool noOrderedClause{false};
   bool isOrderedClauseWithPara{false};
   bool isCloselyNestedRegion{true};
   if (CurrentDirectiveIsNested()) {
     for (int i = (int)dirContext_.size() - 2; i >= 0; i--) {
       if (llvm::omp::nestedOrderedErrSet.test(dirContext_[i].directive)) {
         context_.Say(GetContext().directiveSource,
             "`ORDERED` region may not be closely nested inside of `CRITICAL`, "
             "`ORDERED`, explicit `TASK` or `TASKLOOP` region."_err_en_US);
         break;
-      } else if (llvm::omp::doSet.test(dirContext_[i].directive)) {
+      } else if (llvm::omp::allDoSet.test(dirContext_[i].directive)) {
         isNestedInDo = true;
-        isNestedInDoSIMD = llvm::omp::doSimdSet.test(dirContext_[i].directive);
+        isNestedInDoSIMD =
+            llvm::omp::allDoSimdSet.test(dirContext_[i].directive);
         if (const auto *clause{
                 FindClause(dirContext_[i], llvm::omp::Clause::OMPC_ordered)}) {
           const auto &orderedClause{
               std::get<parser::OmpClause::Ordered>(clause->u)};
           const auto orderedValue{GetIntValue(orderedClause.v)};
           isOrderedClauseWithPara = orderedValue > 0;
         } else {
           noOrderedClause = true;
         }
         break;
-      } else if (llvm::omp::simdSet.test(dirContext_[i].directive)) {
+      } else if (llvm::omp::allSimdSet.test(dirContext_[i].directive)) {
         isNestedInSIMD = true;
         break;
-      } else if (notAllowedParallelSet.test(dirContext_[i].directive)) {
+      } else if (llvm::omp::nestedOrderedParallelErrSet.test(
+                     dirContext_[i].directive)) {
         isCloselyNestedRegion = false;
         break;
       }
     }
   }
 
   if (!isCloselyNestedRegion) {
     context_.Say(GetContext().directiveSource,
for (auto itr = clauseAll.first; itr != clauseAll.second; ++itr) {
     } else {
       context_.Say(itr->second->source,
           "Only DEPEND(SOURCE) or DEPEND(SINK: vec) are allowed when ORDERED "
           "construct is a standalone construct with no ORDERED "
           "region"_err_en_US);
     }
   }
 
-  OmpDirectiveSet allowedDoSet{llvm::omp::Directive::OMPD_do,
-      llvm::omp::Directive::OMPD_parallel_do,
-      llvm::omp::Directive::OMPD_target_parallel_do};
   bool isNestedInDoOrderedWithPara{false};
   if (CurrentDirectiveIsNested() &&
-      allowedDoSet.test(GetContextParent().directive)) {
+      llvm::omp::nestedOrderedDoAllowedSet.test(GetContextParent().directive)) {
     if (const auto *clause{
             FindClause(GetContextParent(), llvm::omp::Clause::OMPC_ordered)}) {
       const auto &orderedClause{
           std::get<parser::OmpClause::Ordered>(clause->u)};
       const auto orderedValue{GetIntValue(orderedClause.v)};
       if (orderedValue > 0) {
         isNestedInDoOrderedWithPara = true;
         CheckOrderedDependClause(orderedValue);
if (CurrentDirectiveIsNested()) {
     // If construct-type-clause is taskgroup, the cancellation construct must be
     // closely nested inside a task or a taskloop construct and the cancellation
     // region must be closely nested inside a taskgroup region. If
     // construct-type-clause is sections, the cancellation construct must be
     // closely nested inside a sections or section construct. Otherwise, the
     // cancellation construct must be closely nested inside an OpenMP construct
     // that matches the type specified in construct-type-clause of the
     // cancellation construct.
-
-    OmpDirectiveSet allowedTaskgroupSet{
-        llvm::omp::Directive::OMPD_task, llvm::omp::Directive::OMPD_taskloop};
-    OmpDirectiveSet allowedSectionsSet{llvm::omp::Directive::OMPD_sections,
-        llvm::omp::Directive::OMPD_parallel_sections};
-    OmpDirectiveSet allowedDoSet{llvm::omp::Directive::OMPD_do,
-        llvm::omp::Directive::OMPD_distribute_parallel_do,
-        llvm::omp::Directive::OMPD_parallel_do,
-        llvm::omp::Directive::OMPD_target_parallel_do,
-        llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do,
-        llvm::omp::Directive::OMPD_teams_distribute_parallel_do};
-    OmpDirectiveSet allowedParallelSet{llvm::omp::Directive::OMPD_parallel,
-        llvm::omp::Directive::OMPD_target_parallel};
-
     bool eligibleCancellation{false};
     switch (type) {
     case parser::OmpCancelType::Type::Taskgroup:
-      if (allowedTaskgroupSet.test(GetContextParent().directive)) {
+      if (llvm::omp::nestedCancelTaskgroupAllowedSet.test(
+              GetContextParent().directive)) {
         eligibleCancellation = true;
         if (dirContext_.size() >= 3) {
           // Check if the cancellation region is closely nested inside a
           // taskgroup region when there are more than two levels of directives
           // in the directive context stack.
           if (GetContextParent().directive == llvm::omp::Directive::OMPD_task ||
               FindClauseParent(llvm::omp::Clause::OMPC_nogroup)) {
             for (int i = dirContext_.size() - 3; i >= 0; i--) {
               if (dirContext_[i].directive ==
                   llvm::omp::Directive::OMPD_taskgroup) {
                 break;
               }
-              if (allowedParallelSet.test(dirContext_[i].directive)) {
+              if (llvm::omp::nestedCancelParallelAllowedSet.test(
+                      dirContext_[i].directive)) {
                 eligibleCancellation = false;
                 break;
               }
             }
           }
         }
       }
       if (!eligibleCancellation) {
         context_.Say(source,
             "With %s clause, %s construct must be closely nested inside TASK "
             "or TASKLOOP construct and %s region must be closely nested inside "
             "TASKGROUP region"_err_en_US,
             parser::ToUpperCaseLetters(
                 parser::OmpCancelType::EnumToString(type)),
             ContextDirectiveAsFortran(), ContextDirectiveAsFortran());
       }
       return;
     case parser::OmpCancelType::Type::Sections:
-      if (allowedSectionsSet.test(GetContextParent().directive)) {
+      if (llvm::omp::nestedCancelSectionsAllowedSet.test(
+              GetContextParent().directive)) {
         eligibleCancellation = true;
       }
       break;
     case Fortran::parser::OmpCancelType::Type::Do:
-      if (allowedDoSet.test(GetContextParent().directive)) {
+      if (llvm::omp::nestedCancelDoAllowedSet.test(
+              GetContextParent().directive)) {
         eligibleCancellation = true;
       }
       break;
     case parser::OmpCancelType::Type::Parallel:
-      if (allowedParallelSet.test(GetContextParent().directive)) {
+      if (llvm::omp::nestedCancelParallelAllowedSet.test(
+              GetContextParent().directive)) {
         eligibleCancellation = true;
       }
       break;
     }
     if (!eligibleCancellation) {
       context_.Say(source,
           "With %s clause, %s construct cannot be closely nested inside %s "
           "construct"_err_en_US,

 // Clauses
 // Mainly categorized as
 // 1. Checks on 'OmpClauseList' from 'parse-tree.h'.
 // 2. Checks on clauses which fall under 'struct OmpClause' from parse-tree.h.
 // 3. Checks on clauses which are not in 'struct OmpClause' from parse-tree.h.
 
 void OmpStructureChecker::Leave(const parser::OmpClauseList &) {
   // 2.7.1 Loop Construct Restriction
-  if (llvm::omp::doSet.test(GetContext().directive)) {
+  if (llvm::omp::allDoSet.test(GetContext().directive)) {
     if (auto *clause{FindClause(llvm::omp::Clause::OMPC_schedule)}) {
       // only one schedule clause is allowed
       const auto &schedClause{std::get<parser::OmpClause::Schedule>(clause->u)};
       if (ScheduleModifierHasType(schedClause.v,
               parser::OmpScheduleModifierType::ModType::Nonmonotonic)) {
         if (FindClause(llvm::omp::Clause::OMPC_ordered)) {
           context_.Say(clause->source,
               "The NONMONOTONIC modifier cannot be specified "
if (auto *clause{FindClause(llvm::omp::Clause::OMPC_ordered)}) {
         }
       }
 
       // TODO: ordered region binding check (requires nesting implementation)
     }
   } // doSet
 
   // 2.8.1 Simd Construct Restriction
-  if (llvm::omp::simdSet.test(GetContext().directive)) {
+  if (llvm::omp::allSimdSet.test(GetContext().directive)) {
     if (auto *clause{FindClause(llvm::omp::Clause::OMPC_simdlen)}) {
       if (auto *clause2{FindClause(llvm::omp::Clause::OMPC_safelen)}) {
         const auto &simdlenClause{
             std::get<parser::OmpClause::Simdlen>(clause->u)};
         const auto &safelenClause{
             std::get<parser::OmpClause::Safelen>(clause2->u)};
         // simdlen and safelen both have parameters
         if (const auto simdlenValue{GetIntValue(simdlenClause.v)}) {

 void OmpStructureChecker::CheckReductionTypeList(
     const parser::OmpClause::Reduction &x) {
   const auto &ompObjectList{std::get<parser::OmpObjectList>(x.v.t)};
   CheckIntentInPointerAndDefinable(
       ompObjectList, llvm::omp::Clause::OMPC_reduction);
   CheckReductionArraySection(ompObjectList);
   // If this is a worksharing construct then ensure the reduction variable
   // is not private in the parallel region that it binds to.
-  OmpDirectiveSet workshareSet{llvm::omp::Directive::OMPD_do,
-      llvm::omp::Directive::OMPD_sections, llvm::omp::Directive::OMPD_do_simd};
-  if (workshareSet.test(GetContext().directive)) {
+  if (llvm::omp::nestedReduceWorkshareAllowedSet.test(GetContext().directive)) {
     CheckSharedBindingInOuterContext(ompObjectList);
   }
 }
 
 void OmpStructureChecker::CheckIntentInPointerAndDefinable(
     const parser::OmpObjectList &objectList, const llvm::omp::Clause clause) {
   for (const auto &ompObject : objectList.v) {
     if (const auto *name{parser::Unwrap<parser::Name>(ompObject)}) {

 }
 
 void OmpStructureChecker::Enter(const parser::OmpClause::Ordered &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_ordered);
   // the parameter of ordered clause is optional
   if (const auto &expr{x.v}) {
     RequiresConstantPositiveParameter(llvm::omp::Clause::OMPC_ordered, *expr);
     // 2.8.3 Loop SIMD Construct Restriction
-    if (llvm::omp::doSimdSet.test(GetContext().directive)) {
+    if (llvm::omp::allDoSimdSet.test(GetContext().directive)) {
       context_.Say(GetContext().clauseSource,
           "No ORDERED clause with a parameter can be specified "
           "on the %s directive"_err_en_US,
           ContextDirectiveAsFortran());
     }
   }
 }
 
if (const auto *compSymbol{structComp->component.symbol}) {
       }
     }
   }
   return dataRefIsTypeParamInquiry;
 }
 
 void OmpStructureChecker::CheckIsVarPartOfAnotherVar(
     const parser::CharBlock &source, const parser::OmpObjectList &objList) {
-  OmpDirectiveSet nonPartialVarSet{llvm::omp::Directive::OMPD_allocate,
-      llvm::omp::Directive::OMPD_allocators,
-      llvm::omp::Directive::OMPD_threadprivate,
-      llvm::omp::Directive::OMPD_declare_target};
   for (const auto &ompObject : objList.v) {
     common::visit(
         common::visitors{
             [&](const parser::Designator &designator) {
               if (const auto *dataRef{
                       std::get_if<parser::DataRef>(&designator.u)}) {
                 if (IsDataRefTypeParamInquiry(dataRef)) {
                   context_.Say(source,
                       "A type parameter inquiry cannot appear on the %s "
                       "directive"_err_en_US,
                       ContextDirectiveAsFortran());
                 } else if (parser::Unwrap<parser::StructureComponent>(
                                ompObject) ||
                     parser::Unwrap<parser::ArrayElement>(ompObject)) {
-                  if (nonPartialVarSet.test(GetContext().directive)) {
+                  if (llvm::omp::nonPartialVarSet.test(
+                          GetContext().directive)) {
                     context_.Say(source,
                         "A variable that is part of another variable (as an "
                         "array or structure element) cannot appear on the %s "
                         "directive"_err_en_US,
                         ContextDirectiveAsFortran());
                   } else {
                     context_.Say(source,
                         "A variable that is part of another variable (as an "
context_.Say(GetContext().clauseSource,
         "clause"_err_en_US);
   }
 }
 void OmpStructureChecker::Enter(const parser::OmpClause::If &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_if);
   using dirNameModifier = parser::OmpIfClause::DirectiveNameModifier;
   // TODO Check that, when multiple 'if' clauses are applied to a combined
   // construct, at most one of them applies to each directive.
-  // Need to define set here because llvm::omp::teamSet does not include target
-  // teams combined constructs.
-  OmpDirectiveSet teamSet{llvm::omp::Directive::OMPD_target_teams,
-      llvm::omp::Directive::OMPD_target_teams_distribute,
-      llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do,
-      llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do_simd,
-      llvm::omp::Directive::OMPD_target_teams_distribute_simd,
-      llvm::omp::Directive::OMPD_teams,
-      llvm::omp::Directive::OMPD_teams_distribute,
-      llvm::omp::Directive::OMPD_teams_distribute_parallel_do,
-      llvm::omp::Directive::OMPD_teams_distribute_parallel_do_simd,
-      llvm::omp::Directive::OMPD_teams_distribute_simd};
   static std::unordered_map<dirNameModifier, OmpDirectiveSet>
-      dirNameModifierMap{{dirNameModifier::Parallel, llvm::omp::parallelSet},
-          {dirNameModifier::Simd, llvm::omp::simdSet},
-          {dirNameModifier::Target, llvm::omp::targetSet},
+      dirNameModifierMap{{dirNameModifier::Parallel, llvm::omp::allParallelSet},
+          {dirNameModifier::Simd, llvm::omp::allSimdSet},
+          {dirNameModifier::Target, llvm::omp::allTargetSet},
           {dirNameModifier::TargetData,
               {llvm::omp::Directive::OMPD_target_data}},
           {dirNameModifier::TargetEnterData,
               {llvm::omp::Directive::OMPD_target_enter_data}},
           {dirNameModifier::TargetExitData,
               {llvm::omp::Directive::OMPD_target_exit_data}},
           {dirNameModifier::TargetUpdate,
               {llvm::omp::Directive::OMPD_target_update}},
           {dirNameModifier::Task, {llvm::omp::Directive::OMPD_task}},
-          {dirNameModifier::Taskloop, llvm::omp::taskloopSet},
-          {dirNameModifier::Teams, teamSet}};
+          {dirNameModifier::Taskloop, llvm::omp::allTaskloopSet},
+          {dirNameModifier::Teams, llvm::omp::allTeamsSet}};
   if (const auto &directiveName{
           std::get<std::optional<dirNameModifier>>(x.v.t)}) {
     auto search{dirNameModifierMap.find(*directiveName)};
     if (search == dirNameModifierMap.end() ||
         !search->second.test(GetContext().directive)) {
       context_
           .Say(GetContext().clauseSource,
               "Unmatched directive name modifier %s on the IF clause"_err_en_US,
               parser::ToUpperCaseLetters(
                   parser::OmpIfClause::EnumToString(*directiveName)))
           .Attach(
               GetContext().directiveSource, "Cannot apply to directive"_en_US);
     }
   }
 }
 
 void OmpStructureChecker::Enter(const parser::OmpClause::Linear &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_linear);
 
   // 2.7 Loop Construct Restriction
-  if ((llvm::omp::doSet | llvm::omp::simdSet).test(GetContext().directive)) {
+  if ((llvm::omp::allDoSet | llvm::omp::allSimdSet)
+          .test(GetContext().directive)) {
     if (std::holds_alternative<parser::OmpLinearClause::WithModifier>(x.v.u)) {
       context_.Say(GetContext().clauseSource,
           "A modifier may not be specified in a LINEAR clause "
           "on the %s directive"_err_en_US,
           ContextDirectiveAsFortran());
     }
   }
 }
bool OmpStructureChecker::ScheduleModifierHasType(
   }
   return false;
 }
 void OmpStructureChecker::Enter(const parser::OmpClause::Schedule &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_schedule);
   const parser::OmpScheduleClause &scheduleClause = x.v;
 
   // 2.7 Loop Construct Restriction
-  if (llvm::omp::doSet.test(GetContext().directive)) {
+  if (llvm::omp::allDoSet.test(GetContext().directive)) {
     const auto &kind{std::get<1>(scheduleClause.t)};
     const auto &chunk{std::get<2>(scheduleClause.t)};
     if (chunk) {
       if (kind == parser::OmpScheduleClause::ScheduleType::Runtime ||
           kind == parser::OmpScheduleClause::ScheduleType::Auto) {
         context_.Say(GetContext().clauseSource,
             "When SCHEDULE clause has %s specified, "
             "it must not have chunk size specified"_err_en_US,
if (parser::Unwrap<parser::AssignmentStmt>(*it) ||
         // statements in the enclosing critical constructs
         const auto &criticalBlock{
             std::get<parser::Block>(ompCriticalConstruct->t)};
         CheckWorkshareBlockStmts(criticalBlock, source);
       } else {
         // Check if OpenMP constructs enclosed in the Workshare construct are
         // 'Parallel' constructs
         auto currentDir{llvm::omp::Directive::OMPD_unknown};
-        const OmpDirectiveSet parallelDirSet{
-            llvm::omp::Directive::OMPD_parallel,
-            llvm::omp::Directive::OMPD_parallel_do,
-            llvm::omp::Directive::OMPD_parallel_sections,
-            llvm::omp::Directive::OMPD_parallel_workshare,
-            llvm::omp::Directive::OMPD_parallel_do_simd};
-
         if (const auto *ompBlockConstruct{
                 std::get_if<parser::OpenMPBlockConstruct>(&ompConstruct->u)}) {
           const auto &beginBlockDir{
               std::get<parser::OmpBeginBlockDirective>(ompBlockConstruct->t)};
           const auto &beginDir{
               std::get<parser::OmpBlockDirective>(beginBlockDir.t)};
           currentDir = beginDir.v;
         } else if (const auto *ompLoopConstruct{
if (parser::Unwrap<parser::AssignmentStmt>(*it) ||
           const auto &beginSectionsDir{
               std::get<parser::OmpBeginSectionsDirective>(
                   ompSectionsConstruct->t)};
           const auto &beginDir{
               std::get<parser::OmpSectionsDirective>(beginSectionsDir.t)};
           currentDir = beginDir.v;
         }
 
-        if (!parallelDirSet.test(currentDir)) {
+        if (!llvm::omp::topParallelSet.test(currentDir)) {
           context_.Say(source,
               "OpenMP constructs enclosed in WORKSHARE construct may consist "
               "of ATOMIC, CRITICAL or PARALLEL constructs only"_err_en_US);
         }
       }
     } else {
       context_.Say(source,
           "The structured block in a WORKSHARE construct may consist of only "

flang/lib/Semantics/resolve-directives.cpp

 
 void OmpAttributeVisitor::ResolveSeqLoopIndexInParallelOrTaskConstruct(
     const parser::Name &iv) {
   auto targetIt{dirContext_.rbegin()};
   for (;; ++targetIt) {
     if (targetIt == dirContext_.rend()) {
       return;
     }
-    if (llvm::omp::parallelSet.test(targetIt->directive) ||
+    if (llvm::omp::allParallelSet.test(targetIt->directive) ||
         llvm::omp::taskGeneratingSet.test(targetIt->directive)) {
       break;
     }
   }
   if (auto *symbol{ResolveOmp(iv, Symbol::Flag::OmpPrivate, targetIt->scope)}) {
     targetIt++;
     symbol->set(Symbol::Flag::OmpPreDetermined);
     iv.symbol = symbol; // adjust the symbol within region

 //     construct with multiple associated do-loops are lastprivate.
 void OmpAttributeVisitor::PrivatizeAssociatedLoopIndexAndCheckLoopLevel(
     const parser::OpenMPLoopConstruct &x) {
   std::int64_t level{GetContext().associatedLoopLevel};
   if (level <= 0) {
     return;
   }
   Symbol::Flag ivDSA;
-  if (!llvm::omp::simdSet.test(GetContext().directive)) {
+  if (!llvm::omp::allSimdSet.test(GetContext().directive)) {
     ivDSA = Symbol::Flag::OmpPrivate;
   } else if (level == 1) {
     ivDSA = Symbol::Flag::OmpLinear;
   } else {
     ivDSA = Symbol::Flag::OmpLastPrivate;
   }
 
   const auto &outer{std::get<std::optional<parser::DoConstruct>>(x.t)};
common::visit(
                         ((ompFlag == Symbol::Flag::OmpUseDeviceAddr) &&
                             symbol->test(Symbol::Flag::OmpUseDevicePtr)))) {
                   context_.Say(designator.source,
                       "Variable '%s' may not "
                       "appear on both USE_DEVICE_PTR and USE_DEVICE_ADDR "
                       "clauses on a TARGET DATA construct"_err_en_US,
                       symbol->name());
                 }
-                if (llvm::omp::distributeSet.test(GetContext().directive) &&
+                if (llvm::omp::allDistributeSet.test(GetContext().directive) &&
                     (((ompFlag == Symbol::Flag::OmpFirstPrivate) &&
                          symbol->test(Symbol::Flag::OmpLastPrivate)) ||
                         ((ompFlag == Symbol::Flag::OmpLastPrivate) &&
                             symbol->test(Symbol::Flag::OmpFirstPrivate)))) {
                   context_.Say(designator.source,
                       "Variable '%s' may not "
                       "appear on both FIRSTPRIVATE and LASTPRIVATE "
                       "clauses on a DISTRIBUTE construct"_err_en_US,