Fix ASSUME -> ASSUMES and vice versa

Author: Leporacanthicus

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

@@ -674,10 +674,8 @@ class ParseTreeDumper {
   NODE(parser, OpenACCWaitConstruct)
   NODE(parser, OpenMPAssumeConstruct)
   NODE(parser, OpenMPDeclarativeAssumes)
-  NODE(parser, OmpAssumesPartConstruct)
-  NODE(parser, OmpAssumesDirective)
-  NODE(parser, OpenMPAssumesConstruct)
-  NODE(parser, OmpEndAssumesDirective)
+  NODE(parser, OmpAssumeDirective)
+  NODE(parser, OmpEndAssumeDirective)
   NODE(parser, OpenMPAtomicConstruct)
   NODE(parser, OpenMPBlockConstruct)
   NODE(parser, OpenMPCancelConstruct)

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

@@ -4446,44 +4446,36 @@ struct OpenMPUtilityConstruct {
 
 // Ref: [5.2: 213-216]
 //
-// assume-construct ->
-//   ASSUME absent-clause | contains-clause | holds-clause | no-openmp-clause |
+// assumes-construct ->
+//   ASSUMES absent-clause | contains-clause | holds-clause | no-openmp-clause |
 //          no-openmp-routines-clause | no-parallelism-clause
-struct OpenMPAssumeConstruct {
-  TUPLE_CLASS_BOILERPLATE(OpenMPAssumeConstruct);
-  std::tuple<Verbatim, OmpClauseList> t;
-  CharBlock source;
-};
-
 struct OpenMPDeclarativeAssumes {
   TUPLE_CLASS_BOILERPLATE(OpenMPDeclarativeAssumes);
   std::tuple<Verbatim, OmpClauseList> t;
   CharBlock source;
 };
 
-struct OmpAssumesDirective {
-  TUPLE_CLASS_BOILERPLATE(OmpAssumesDirective);
+struct OmpAssumeDirective {
+  TUPLE_CLASS_BOILERPLATE(OmpAssumeDirective);
   std::tuple<Verbatim, OmpClauseList> t;
   CharBlock source;
 };
 
-struct OmpEndAssumesDirective {
-  WRAPPER_CLASS_BOILERPLATE(OmpEndAssumesDirective, Verbatim);
+struct OmpEndAssumeDirective {
+  WRAPPER_CLASS_BOILERPLATE(OmpEndAssumeDirective, Verbatim);
   CharBlock source;
 };
 
-//    structured-block
-// ...
-struct OmpAssumesPartConstruct {
-  WRAPPER_CLASS_BOILERPLATE(OmpAssumesPartConstruct, Block);
-  CharBlock source;
-};
-
-struct OpenMPAssumesConstruct {
-  TUPLE_CLASS_BOILERPLATE(OpenMPAssumesConstruct);
-  std::tuple<OmpAssumesDirective, OmpAssumesPartConstruct,
-      OmpEndAssumesDirective>
-      t;
+// Ref: [5.2: 213-216]
+//
+// assume-construct ->
+//   ASSUME absent-clause | contains-clause | holds_clause | no-openmp-clause
+//          no-openmp-routines-clause | no-parallelism-clause
+//       block
+//   [END ASSUME]
+struct OpenMPAssumeConstruct {
+  TUPLE_CLASS_BOILERPLATE(OpenMPAssumeConstruct);
+  std::tuple<OmpAssumeDirective, Block, std::optional<OmpEndAssumeDirective>> t;
   CharBlock source;
 };
 
@@ -4620,7 +4612,7 @@ struct OpenMPDeclarativeAllocate {
 struct OpenMPDeclarativeConstruct {
   UNION_CLASS_BOILERPLATE(OpenMPDeclarativeConstruct);
   CharBlock source;
-  std::variant<OpenMPDeclarativeAllocate, OpenMPAssumesConstruct, OpenMPDeclarativeAssume,
+  std::variant<OpenMPDeclarativeAllocate, OpenMPAssumeConstruct, OpenMPDeclarativeAssumes,
       OpenMPDeclareMapperConstruct,
       OpenMPDeclareReductionConstruct, OpenMPDeclareSimdConstruct,
       OpenMPDeclareTargetConstruct, OpenMPThreadprivate,

flang/lib/Lower/OpenMP/OpenMP.cpp

@@ -3385,20 +3385,10 @@ static void genOMP(lower::AbstractConverter &converter, lower::SymMap &symTable,
                    semantics::SemanticsContext &semaCtx,
                    lower::pft::Evaluation &eval,
                    const parser::OpenMPAssumeConstruct &assumeConstruct) {
-  const auto &verbatim = std::get<parser::Verbatim>(assumeConstruct.t);
-  mlir::Location clauseLocation = converter.genLocation(verbatim.source);
+  mlir::Location clauseLocation = converter.genLocation(assumeConstruct.source);
   TODO(clauseLocation, "OpenMP ASSUME construct");
 }
 
-static void genOMP(lower::AbstractConverter &converter, lower::SymMap &symTable,
-                   semantics::SemanticsContext &semaCtx,
-                   lower::pft::Evaluation &eval,
-                   const parser::OpenMPAssumesConstruct &assumesConstruct) {
-  mlir::Location clauseLocation =
-      converter.genLocation(assumesConstruct.source);
-  TODO(clauseLocation, "OpenMP ASSUMES construct");
-}
-
 static void genOMP(lower::AbstractConverter &converter, lower::SymMap &symTable,
                    semantics::SemanticsContext &semaCtx,
                    lower::pft::Evaluation &eval,

flang/lib/Parser/openmp-parsers.cpp

@@ -1323,22 +1323,15 @@ TYPE_PARSER(startOmpLine >>
             endOmpLine))
 
 // Assume Construct
-TYPE_PARSER(sourced(construct<OpenMPAssumeConstruct>(
-                        verbatim("ASSUME"_tok), Parser<OmpClauseList>{}) /
-    endOmpLine))
+TYPE_PARSER(sourced(construct<OmpAssumeDirective>(
+    verbatim("ASSUME"_tok), Parser<OmpClauseList>{})))
 
-TYPE_PARSER(sourced(construct<OmpAssumesDirective>(
-    verbatim("ASSUMES"_tok), Parser<OmpClauseList>{})))
-
-TYPE_PARSER(sourced(construct<OmpEndAssumesDirective>(
-    verbatim(startOmpLine >> "END ASSUMES"_tok))))
+TYPE_PARSER(sourced(construct<OmpEndAssumeDirective>(
+    verbatim(startOmpLine >> "END ASSUME"_tok))))
 
-TYPE_PARSER(construct<OmpAssumesPartConstruct>(block))
-
-TYPE_PARSER(sourced(construct<OpenMPAssumesConstruct>(
-    Parser<OmpAssumesDirective>{} / endOmpLine,
-    Parser<OmpAssumesPartConstruct>{},
-    Parser<OmpEndAssumesDirective>{} / endOmpLine)))
+TYPE_PARSER(sourced(
+    construct<OpenMPAssumeConstruct>(Parser<OmpAssumeDirective>{} / endOmpLine,
+        block, maybe(Parser<OmpEndAssumeDirective>{} / endOmpLine))))
 
 // Block Construct
 TYPE_PARSER(construct<OpenMPBlockConstruct>(
@@ -1387,7 +1380,6 @@ TYPE_CONTEXT_PARSER("OpenMP construct"_en_US,
                 construct<OpenMPConstruct>(Parser<OpenMPExecutableAllocate>{}),
                 construct<OpenMPConstruct>(Parser<OpenMPAllocatorsConstruct>{}),
                 construct<OpenMPConstruct>(Parser<OpenMPDeclarativeAllocate>{}),
-                construct<OpenMPConstruct>(Parser<OpenMPAssumesConstruct>{}),
                 construct<OpenMPConstruct>(Parser<OpenMPAssumeConstruct>{}),
                 construct<OpenMPConstruct>(Parser<OpenMPCriticalConstruct>{}))))
 

flang/lib/Parser/unparse.cpp

@@ -2641,23 +2641,16 @@ class UnparseVisitor {
       Walk(*end);
     }
   }
-  void Unparse(const OpenMPAssumeConstruct &x) {
+  void Unparse(const OmpAssumeDirective &x) {
     BeginOpenMP();
     Word("!$OMP ASSUME");
     Walk(std::get<OmpClauseList>(x.t), ", ");
     Put("\n");
     EndOpenMP();
   }
-  void Unparse(const OmpAssumesDirective &x) {
+  void Unparse(const OmpEndAssumeDirective &x) {
     BeginOpenMP();
-    Word("!$OMP ASSUMES");
-    Walk(std::get<OmpClauseList>(x.t), ", ");
-    Put("\n");
-    EndOpenMP();
-  }
-  void Unparse(const OmpEndAssumesDirective &x) {
-    BeginOpenMP();
-    Word("!$OMP END ASSUMES\n");
+    Word("!$OMP END ASSUME\n");
     EndOpenMP();
   }
   void Unparse(const OmpCriticalDirective &x) {

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

@@ -1252,8 +1252,7 @@ void OmpStructureChecker::CheckMasterNesting(
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPAssumeConstruct &x) {
-  const auto &dir{std::get<parser::Verbatim>(x.t)};
-  PushContextAndClauseSets(dir.source, llvm::omp::Directive::OMPD_assume);
+  PushContextAndClauseSets(x.source, llvm::omp::Directive::OMPD_assume);
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPAssumeConstruct &) {
@@ -1268,14 +1267,6 @@ void OmpStructureChecker::Leave(const parser::OpenMPDeclarativeAssumes &) {
   dirContext_.pop_back();
 }
 
-void OmpStructureChecker::Enter(const parser::OpenMPAssumesConstruct &x) {
-  PushContextAndClauseSets(x.source, llvm::omp::Directive::OMPD_assumes);
-}
-
-void OmpStructureChecker::Leave(const parser::OpenMPAssumesConstruct &) {
-  dirContext_.pop_back();
-}
-
 void OmpStructureChecker::Leave(const parser::OpenMPBlockConstruct &) {
   if (GetDirectiveNest(TargetBlockOnlyTeams)) {
     ExitDirectiveNest(TargetBlockOnlyTeams);

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

@@ -85,8 +85,6 @@ class OmpStructureChecker
   void Leave(const parser::OpenMPAssumeConstruct &);
   void Enter(const parser::OpenMPDeclarativeAssumes &);
   void Leave(const parser::OpenMPDeclarativeAssumes &);
-  void Enter(const parser::OpenMPAssumesConstruct &);
-  void Leave(const parser::OpenMPAssumesConstruct &);
   void Enter(const parser::OpenMPBlockConstruct &);
   void Leave(const parser::OpenMPBlockConstruct &);
   void Leave(const parser::OmpBeginBlockDirective &);

flang/test/Lower/OpenMP/Todo/assume.f90

@@ -2,5 +2,9 @@
 
 ! CHECK: not yet implemented: OpenMP ASSUME construct
 program p
-  !$omp assume no_openmp
+  integer r
+  r = 1
+!$omp assume no_parallelism
+  print *,r
+!$omp end assume
 end program p

flang/test/Lower/OpenMP/Todo/assumes.f90

@@ -1,10 +1,6 @@
 ! RUN: %not_todo_cmd %flang_fc1 -emit-fir -fopenmp -fopenmp-version=51 -o - %s 2>&1 | FileCheck %s
 
-! CHECK: not yet implemented: OpenMP ASSUMES construct
+! CHECK: not yet implemented: OpenMP ASSUMES declaration
 program p
-  integer r
-  r = 1
-!$omp assumes no_parallelism
-  print *,r
-!$omp end assumes
+  !$omp assumes no_openmp
 end program p

flang/test/Parser/OpenMP/assumption.f90

@@ -32,20 +32,20 @@ end subroutine sub1
 subroutine sub2
   integer :: r
   integer :: v
-!CHECK !$OMP ASSUMES NO_OPENMP
-!PARSE-TREE: ExecutionPartConstruct -> ExecutableConstruct -> OpenMPConstruct -> OpenMPAssumesConstruct
-!PARSE-TREE: OmpAssumesDirective
+!CHECK !$OMP ASSUME NO_OPENMP
+!PARSE-TREE: ExecutionPartConstruct -> ExecutableConstruct -> OpenMPConstruct -> OpenMPAssumeConstruct
+!PARSE-TREE: OmpAssumeDirective
 !PARSE-TREE: Verbatim
 !PARSE-TREE: OmpClauseList -> OmpClause -> NoOpenmp
-!PARSE-TREE: OmpAssumesPartConstruct -> Block
+!PARSE-TREE: Block
 !PARSE-TREE: ExecutionPartConstruct -> ExecutableConstruct -> ActionStmt -> AssignmentStmt
 !PARSE-TREE: Expr -> Add
-  !PARSE-TREE: OmpEndAssumesDirective
+!PARSE-TREE: OmpEndAssumeDirective
   v = 87
-  !$omp assumes no_openmp
+  !$omp assume no_openmp
   r = r + 1
-!CHECK !$OMP END ASSUMES
-  !$omp end assumes
+!CHECK !$OMP END ASSUME
+  !$omp end assume
 end subroutine sub2
 
 program p