[flang][OpenMP] Added parser support for Iterators (OpenMP 5.0) and updated depend clause

[kiranktp]

Summary

This patch adds parser support for Iterators [OpenMP 5.0] and updated depend clause to include Iterators.

2.1.6 Iterators
iterator(iterators-definition)

		where iterators-definition is
		iterator-specifier [, iterators-definition ]
		where iterator-specifier is
		[ iterator-type :: ] identifier = range-specification

2.17.11 depend Clause
depend([depend-modifier,]dependence-type : locator-list)

		where dependence-type is
		in out inout mutexinoutset depobj
		where depend-modifier is
		iterator(iterators-definition)

The patch includes code changes and testcase modifications.

[kiranktp]

Corrected the test case

[kiranktp]

Corrected the section number to 2.17.11 [From OpenMP 5.0] for Depend clause.
Removed the dependence type (inoutset) which is from OpenMP 5.1.

[kiranktp]

`

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

#define NODE(T1, T2) NODE_NAME(T1::T2, #T2)
   NODE(parser, OmpDeclareTargetSpecifier)
   NODE(parser, OmpDeclareTargetWithClause)
   NODE(parser, OmpDeclareTargetWithList)
   NODE(parser, OmpDefaultClause)
   NODE_ENUM(OmpDefaultClause, Type)
   NODE(parser, OmpDefaultmapClause)
   NODE_ENUM(OmpDefaultmapClause, ImplicitBehavior)
   NODE_ENUM(OmpDefaultmapClause, VariableCategory)
+  NODE(parser, OmpIteratorSpecifier)
+  NODE(parser, OmpIteratorSpecifierList)
+  NODE(parser, OmpIterator)
   NODE(parser, OmpDependClause)
   NODE(OmpDependClause, InOut)
   NODE(OmpDependClause, Sink)
   NODE(OmpDependClause, Source)
   NODE(parser, OmpDependenceType)
   NODE_ENUM(OmpDependenceType, Type)
   NODE(parser, OmpDependSinkVec)
   NODE(parser, OmpDependSinkVecLength)

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

 
 struct AssignedGotoStmt {
   TUPLE_CLASS_BOILERPLATE(AssignedGotoStmt);
   std::tuple<Name, std::list<Label>> t;
 };
 
 WRAPPER_CLASS(PauseStmt, std::optional<StopCode>);
 
-// Parse tree nodes for OpenMP 4.5 directives and clauses
+// Parse tree nodes for OpenMP 4.5/5.0 directives and clauses
+
+// 2.1.6 Iterators [OpenMP 5.0]
+// iterators-specifier -> [ iterator-type ] identifier = range-specification
+// iterator-type -> integer type
+// range-specification -> begin:end[:step]
+struct OmpIteratorSpecifier {
+  TUPLE_CLASS_BOILERPLATE(OmpIteratorSpecifier);
+  CharBlock source;
+  using Bounds = LoopBounds<DoVariable, ScalarIntExpr>;
+  std::tuple<std::optional<IntegerTypeSpec>, Bounds> t;
+};
+
+WRAPPER_CLASS(OmpIteratorSpecifierList, std::list<OmpIteratorSpecifier>);
+
+// 2.1.6 iterators -> iterator(iterators-definition)
+// iterators-definition -> iterator-specifier [, iterators-definition ]
+struct OmpIterator {
+  TUPLE_CLASS_BOILERPLATE(OmpIterator);
+  CharBlock source;
+  std::tuple<Verbatim, OmpIteratorSpecifierList> t;
+};
 
 // 2.5 proc-bind-clause -> PROC_BIND (MASTER | CLOSE | SPREAD)
 struct OmpProcBindClause {
   ENUM_CLASS(Type, Close, Master, Spread)
   WRAPPER_CLASS_BOILERPLATE(OmpProcBindClause, Type);
 };
 
 // 2.15.3.1 default-clause -> DEFAULT (PRIVATE | FIRSTPRIVATE | SHARED | NONE)

 
 // 2.15.3.6 reduction-clause -> REDUCTION (reduction-identifier:
 //                                         variable-name-list)
 struct OmpReductionClause {
   TUPLE_CLASS_BOILERPLATE(OmpReductionClause);
   std::tuple<OmpReductionOperator, std::list<Designator>> t;
 };
 
-// 2.13.9 depend-vec-length -> +/- non-negative-constant
+// 2.17.11 Depend Clause [OpenMP 5.0]
+// 2.17.11 depend-vec-length -> +/- non-negative-constant
 struct OmpDependSinkVecLength {
   TUPLE_CLASS_BOILERPLATE(OmpDependSinkVecLength);
   std::tuple<DefinedOperator, ScalarIntConstantExpr> t;
 };
 
-// 2.13.9 depend-vec -> iterator [+/- depend-vec-length],...,iterator[...]
+// 2.17.11 depend-vec -> iterator [+/- depend-vec-length],...,iterator[...]
 struct OmpDependSinkVec {
   TUPLE_CLASS_BOILERPLATE(OmpDependSinkVec);
   std::tuple<Name, std::optional<OmpDependSinkVecLength>> t;
 };
 
-// 2.13.9 depend-type -> IN | OUT | INOUT | SOURCE | SINK
+// 2.17.11 dependence-type -> IN | OUT | INOUT | MUTEXINOUTSET | DEPOBJ
 struct OmpDependenceType {
-  ENUM_CLASS(Type, In, Out, Inout, Source, Sink)
+  ENUM_CLASS(Type, In, Out, Inout, Mutexinoutset, Depobj)
   WRAPPER_CLASS_BOILERPLATE(OmpDependenceType, Type);
 };
 
-// 2.13.9 depend-clause -> DEPEND (((IN | OUT | INOUT) : variable-name-list) |
-//                                 SOURCE | SINK : depend-vec)
+// 2.17.11 depend-clause -> DEPEND (([ITERATOR(iterators-definition),]
+//                                   (IN | OUT | INOUT |
+//                                    MUTEXINOUTSET | DEPOBJ) :
+//                                   variable-name-list) |
+//                                  SOURCE |
+//                                  SINK : depend-vec)
 struct OmpDependClause {
   UNION_CLASS_BOILERPLATE(OmpDependClause);
   EMPTY_CLASS(Source);
   WRAPPER_CLASS(Sink, std::list<OmpDependSinkVec>);
   struct InOut {
     TUPLE_CLASS_BOILERPLATE(InOut);
-    std::tuple<OmpDependenceType, std::list<Designator>> t;
+    std::tuple<std::optional<OmpIterator>, OmpDependenceType,
+        std::list<Designator>>
+        t;
   };
+  CharBlock source;
   std::variant<Source, Sink, InOut> u;
 };
 
 // 2.7.1 nowait-clause -> NOWAIT
 EMPTY_CLASS(OmpNowait);
 
 // OpenMP Clauses
 struct OmpClause {

flang/include/flang/Semantics/scope.h

 };
 using EquivalenceSet = std::vector<EquivalenceObject>;
 
 class Scope {
   using mapType = std::map<SourceName, MutableSymbolRef>;
 
 public:
   ENUM_CLASS(Kind, Global, Module, MainProgram, Subprogram, BlockData,
-      DerivedType, Block, Forall, ImpliedDos)
+      DerivedType, Block, Forall, ImpliedDos, OmpIterators)
   using ImportKind = common::ImportKind;
 
   // Create the Global scope -- the root of the scope tree
   Scope() : Scope{*this, Kind::Global, nullptr} {}
   Scope(Scope &parent, Kind kind, Symbol *symbol)
       : parent_{parent}, kind_{kind}, symbol_{symbol} {
     if (symbol) {
       symbol->set_scope(this);

flang/lib/Parser/expr-parsers.h

 inline constexpr auto loopBounds(decltype(scalarExpr) &p) {
   return construct<LoopBounds<ScalarName, ScalarExpr>>(
       scalar(name) / "=", p / ",", p, maybe("," >> p));
 }
 template <typename PA> inline constexpr auto loopBounds(const PA &p) {
   return construct<LoopBounds<DoVariable, typename PA::resultType>>(
       doVariable / "=", p / ",", p, maybe("," >> p));
 }
+template <typename PA> inline constexpr auto ompLoopBounds(const PA &p) {
+  return construct<LoopBounds<DoVariable, typename PA::resultType>>(
+      doVariable / "=", p / ":", p, maybe(":" >> p));
+}
 } // namespace Fortran::parser
 #endif

flang/lib/Parser/openmp-parsers.cpp

 
 constexpr auto startOmpLine = skipStuffBeforeStatement >> "!$OMP "_sptok;
 constexpr auto endOmpLine = space >> endOfLine;
 
 template <typename A> constexpr decltype(auto) verbatim(A x) {
   return sourced(construct<Verbatim>(x));
 }
 
+// 2.1.6 ITERATOR(iterators-definition)
+//        iterators-definition -> iterator-specifier [, iterators-definition ]
+//        iterator-specifier -> [ iterator-type ] identifier =
+//                                     range-specification
+TYPE_PARSER(sourced(construct<OmpIteratorSpecifier>(
+    maybe(integerTypeSpec / "::"), ompLoopBounds(scalarIntExpr))))
+
+TYPE_PARSER(construct<OmpIteratorSpecifierList>(
+    many(maybe(","_tok) >> Parser<OmpIteratorSpecifier>{})))
+
+TYPE_PARSER(sourced(construct<OmpIterator>(verbatim("ITERATOR"_tok),
+    parenthesized(Parser<OmpIteratorSpecifierList>{}))))
+
 // OpenMP Clauses
 // 2.15.3.1 DEFAULT (PRIVATE | FIRSTPRIVATE | SHARED | NONE)
 TYPE_PARSER(construct<OmpDefaultClause>(
     "PRIVATE" >> pure(OmpDefaultClause::Type::Private) ||
     "FIRSTPRIVATE" >> pure(OmpDefaultClause::Type::Firstprivate) ||
     "SHARED" >> pure(OmpDefaultClause::Type::Shared) ||
     "NONE" >> pure(OmpDefaultClause::Type::None)))
 

 
 // 2.15.3.6 REDUCTION (reduction-identifier: variable-name-list)
 TYPE_PARSER(construct<OmpReductionOperator>(Parser<DefinedOperator>{}) ||
     construct<OmpReductionOperator>(Parser<ProcedureDesignator>{}))
 
 TYPE_PARSER(construct<OmpReductionClause>(
     Parser<OmpReductionOperator>{} / ":", nonemptyList(designator)))
 
-// 2.13.9 DEPEND (SOURCE | SINK : vec | (IN | OUT | INOUT) : list
+// 2.17.11 DEPEND (source-dependence | sink-dependence | other-dependence)
+//          source-dependence -> SOURCE
+//          sink-dependence   -> SINK : vec
+//          other-dependence  -> dependence-modifier dependence-type : list
+//           dependence-modifier   -> [ITERATOR(iterators-definition), ]
+//           dependence-type   -> IN | OUT | INOUT | MUTEXINOUTSET | DEPOBJ
 TYPE_PARSER(construct<OmpDependSinkVecLength>(
     Parser<DefinedOperator>{}, scalarIntConstantExpr))
 
 TYPE_PARSER(
     construct<OmpDependSinkVec>(name, maybe(Parser<OmpDependSinkVecLength>{})))
 
 TYPE_PARSER(
     construct<OmpDependenceType>("IN"_id >> pure(OmpDependenceType::Type::In) ||
+        "OUT" >> pure(OmpDependenceType::Type::Out) ||
         "INOUT" >> pure(OmpDependenceType::Type::Inout) ||
-        "OUT" >> pure(OmpDependenceType::Type::Out)))
+        "MUTEXINOUTSET" >> pure(OmpDependenceType::Type::Mutexinoutset) ||
+        "DEPOBJ" >> pure(OmpDependenceType::Type::Depobj)))
 
 TYPE_CONTEXT_PARSER("Omp Depend clause"_en_US,
     construct<OmpDependClause>(construct<OmpDependClause::Sink>(
         "SINK :" >> nonemptyList(Parser<OmpDependSinkVec>{}))) ||
         construct<OmpDependClause>(
             construct<OmpDependClause::Source>("SOURCE"_tok)) ||
-        construct<OmpDependClause>(construct<OmpDependClause::InOut>(
-            Parser<OmpDependenceType>{}, ":" >> nonemptyList(designator))))
+        sourced(construct<OmpDependClause>(
+            construct<OmpDependClause::InOut>(maybe(Parser<OmpIterator>{}),
+                maybe(","_tok) >> Parser<OmpDependenceType>{},
+                ":" >> nonemptyList(designator)))))
 
 // 2.15.3.7 LINEAR (linear-list: linear-step)
 //          linear-list -> list | modifier(list)
 //          linear-modifier -> REF | VAL | UVAL
 TYPE_PARSER(
     construct<OmpLinearModifier>("REF" >> pure(OmpLinearModifier::Type::Ref) ||
         "VAL" >> pure(OmpLinearModifier::Type::Val) ||
         "UVAL" >> pure(OmpLinearModifier::Type::Uval)))

flang/lib/Parser/unparse.cpp

if (!list.empty()) {
       for (const char *tkr : list) {
         Put(*tkr);
       }
       Put(") ");
     }
     Walk(std::get<Name>(x.t));
   }
   // OpenMP Clauses & Directives
+  void Unparse(const OmpIteratorSpecifier &x) {
+    Walk(std::get<std::optional<IntegerTypeSpec>>(x.t), "::");
+    const auto &bounds{std::get<OmpIteratorSpecifier::Bounds>(x.t)};
+    Walk(bounds.name), Put('=');
+    Walk(bounds.lower), Put(':'), Walk(bounds.upper), Walk(":", bounds.step);
+  }
+  void Unparse(const OmpIteratorSpecifierList &x) { Walk(" ", x.v, ", "); }
+  void Unparse(const OmpIterator &x) {
+    Word("ITERATOR(");
+    Walk(std::get<OmpIteratorSpecifierList>(x.t));
+    Put(")");
+  }
   void Unparse(const OmpObject &x) {
     std::visit(common::visitors{
                    [&](const Designator &y) { Walk(y); },
                    [&](const Name &y) { Put("/"), Walk(y), Put("/"); },
                },
         x.u);
   }
   void Unparse(const OmpMapType::Always &) { Word("ALWAYS,"); }
void Unparse(const OmpDependSinkVecLength &x) {
     Walk(std::get<ScalarIntConstantExpr>(x.t));
   }
   void Unparse(const OmpDependSinkVec &x) {
     Walk(std::get<Name>(x.t));
     Walk(std::get<std::optional<OmpDependSinkVecLength>>(x.t));
   }
   void Unparse(const OmpDependClause::InOut &x) {
     Put("(");
+    Walk(std::get<std::optional<OmpIterator>>(x.t), ", ");
     Walk(std::get<OmpDependenceType>(x.t));
     Put(":");
     Walk(std::get<std::list<Designator>>(x.t), ",");
     Put(")");
   }
   bool Pre(const OmpDependClause &x) {
     return std::visit(common::visitors{
                           [&](const OmpDependClause::Source &) {

flang/lib/Semantics/resolve-names.cpp

 
 // Create scopes for OpenMP constructs
 class OmpVisitor : public virtual DeclarationVisitor {
 public:
   void AddOmpSourceRange(const parser::CharBlock &);
 
   static bool NeedsScope(const parser::OpenMPBlockConstruct &);
 
+  bool Pre(const parser::OmpIteratorSpecifier &);
+  bool Pre(const parser::OmpDependClause &);
+  void Post(const parser::OmpDependClause &);
   bool Pre(const parser::OpenMPBlockConstruct &);
   void Post(const parser::OpenMPBlockConstruct &);
   bool Pre(const parser::OmpBeginBlockDirective &x) {
     AddOmpSourceRange(x.source);
     return true;
   }
   void Post(const parser::OmpBeginBlockDirective &) {
     messageHandler().set_currStmtSource(std::nullopt);
if (init) {
       }
     }
   }
 
   ResolveNamesVisitor &resolver_;
   bool pushedScope_{false};
 };
 
+bool OmpVisitor::Pre(const parser::OmpIteratorSpecifier &x) {
+  auto &type{std::get<std::optional<parser::IntegerTypeSpec>>(x.t)};
+  auto &bounds{std::get<parser::OmpIteratorSpecifier::Bounds>(x.t)};
+  DeclareStatementEntity(bounds.name.thing.thing, type);
+  Walk(bounds);
+  return false;
+}
+
+bool OmpVisitor::Pre(const parser::OmpDependClause &x) {
+  messageHandler().set_currStmtSource(x.source);
+  std::visit(
+      common::visitors{
+          [&](const parser::OmpDependClause::Source &) {},
+          [&](const parser::OmpDependClause::Sink &) {},
+          [&](const parser::OmpDependClause::InOut &y) {
+            PushScope(Scope::Kind::OmpIterators, nullptr);
+            Walk(y);
+            PopScope();
+          },
+      },
+      x.u);
+  return false;
+}
+
+void OmpVisitor::Post(const parser::OmpDependClause &) {
+  messageHandler().set_currStmtSource(std::nullopt);
+}
+
 bool OmpAttributeVisitor::Pre(const parser::OpenMPBlockConstruct &x) {
   const auto &beginBlockDir{std::get<parser::OmpBeginBlockDirective>(x.t)};
   const auto &beginDir{std::get<parser::OmpBlockDirective>(beginBlockDir.t)};
   switch (beginDir.v) {
   case parser::OmpBlockDirective::Directive::Master:
     PushContext(beginDir.source, OmpDirective::MASTER);
     break;
   case parser::OmpBlockDirective::Directive::Ordered:

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

!                      priority-clause
   b = 1
   !$omp end task
 
   !ERROR: The parameter of the PRIORITY clause must be a positive integer expression
   !$omp task priority(-1) firstprivate(a) mergeable
   a = 3.14
   !$omp end task
 
+  !$omp task depend(iterator( it=1_4:100:2), in:arrayA(it))
+  a = 3.14
+  !$omp end task
+
+  !$omp task depend(iterator(integer :: it=1_4:100:2), in:arrayA(it))
+  a = 3.14
+  !$omp end task
+
+  !$omp task depend(in: b) depend(mutexinoutset: c)
+  a = 3.14
+  !$omp end task
+
+  !$omp task depend(depobj: obj)
+  a = 3.14
+  !$omp end task
+
 ! 2.9.3 taskloop-simd-clause -> taskloop-clause |
 !                               simd-clause
 
   !$omp taskloop simd
   do i = 1, N
      a = 3.14
   enddo
   !$omp end taskloop simd