[flang] Fixed restrictions checking for OpenACC loop-associated constructs.

[vzakhari]

Summary

CheckDoConcurrentClauseRestriction and CheckTileClauseRestriction expect
that the construct has associated DoConstruct, while it is not set
when the do-loop has no loop control. The change is to skip the clauses
checks, when the do-loop does not have the loop control.

An alternative fix would be to associate the DoConstruct even when
the do-loop has no loop control and let Check*ClauseRestriction run their
checks, but I am not sure if associating invalid DoConstruct is a good idea.

This fixes failure in Semantics/OpenACC/acc-canonicalization-validity.f90
reported in D142279.

[clementval]

Thanks for fixing this Slava!

flang/lib/Semantics/canonicalize-acc.cpp

void RewriteOpenACCLoopConstruct(parser::OpenACCLoopConstruct &x,
     //     DoConstruct
     parser::Block::iterator nextIt;
     auto &beginDir{std::get<parser::AccBeginLoopDirective>(x.t)};
     auto &dir{std::get<parser::AccLoopDirective>(beginDir.t)};
 
     nextIt = it;
     if (++nextIt != block.end()) {
       if (auto *doCons{parser::Unwrap<parser::DoConstruct>(*nextIt)}) {
-        if (doCons->GetLoopControl()) {
-          // move DoConstruct
-          std::get<std::optional<parser::DoConstruct>>(x.t) =
-              std::move(*doCons);
-          nextIt = block.erase(nextIt);
-        } else {
+        if (!doCons->GetLoopControl()) {
           messages_.Say(dir.source,
               "DO loop after the %s directive must have loop control"_err_en_US,
               parser::ToUpperCaseLetters(dir.source.ToString()));
+          return;
         }
 
+        // move DoConstruct
+        std::get<std::optional<parser::DoConstruct>>(x.t) = std::move(*doCons);
+        nextIt = block.erase(nextIt);
+
         CheckDoConcurrentClauseRestriction<parser::OpenACCLoopConstruct,
             parser::AccBeginLoopDirective>(x);
         CheckTileClauseRestriction<parser::OpenACCLoopConstruct,
             parser::AccBeginLoopDirective>(x);
 
         return; // found do-loop
       }
     }
void RewriteOpenACCCombinedConstruct(parser::OpenACCCombinedConstruct &x,
     //     AccEndCombinedDirective (if available)
     parser::Block::iterator nextIt;
     auto &beginDir{std::get<parser::AccBeginCombinedDirective>(x.t)};
     auto &dir{std::get<parser::AccCombinedDirective>(beginDir.t)};
 
     nextIt = it;
     if (++nextIt != block.end()) {
       if (auto *doCons{parser::Unwrap<parser::DoConstruct>(*nextIt)}) {
-        if (doCons->GetLoopControl()) {
-          // move DoConstruct
-          std::get<std::optional<parser::DoConstruct>>(x.t) =
-              std::move(*doCons);
-          nextIt = block.erase(nextIt);
-          // try to match AccEndCombinedDirective
-          if (nextIt != block.end()) {
-            if (auto *endDir{
-                    parser::Unwrap<parser::AccEndCombinedDirective>(*nextIt)}) {
-              std::get<std::optional<parser::AccEndCombinedDirective>>(x.t) =
-                  std::move(*endDir);
-              block.erase(nextIt);
-            }
-          }
-        } else {
-          messages_.Say(dir.source,
-              "DO loop after the %s directive must have loop control"_err_en_US,
-              parser::ToUpperCaseLetters(dir.source.ToString()));
-        }
+        if (!doCons->GetLoopControl()) {
+          messages_.Say(dir.source,
+              "DO loop after the %s directive must have loop control"_err_en_US,
+              parser::ToUpperCaseLetters(dir.source.ToString()));
+          return;
+        }
+        std::get<std::optional<parser::DoConstruct>>(x.t) = std::move(*doCons);
 
         CheckDoConcurrentClauseRestriction<parser::OpenACCCombinedConstruct,
             parser::AccBeginCombinedDirective>(x);
         CheckTileClauseRestriction<parser::OpenACCCombinedConstruct,
             parser::AccBeginCombinedDirective>(x);
 
         return; // found do-loop
       }