[flang][OpenMP] Remove redundant Fortran:: from namespaces, NFC

Apply clang-format after the changes.

Author: kparzysz

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

@@ -554,18 +554,16 @@ void OmpStructureChecker::CheckHintClause(
     D *leftOmpClauseList, D *rightOmpClauseList) {
   auto checkForValidHintClause = [&](const D *clauseList) {
     for (const auto &clause : clauseList->v) {
-      const Fortran::parser::OmpClause *ompClause = nullptr;
-      if constexpr (std::is_same_v<D,
-                        const Fortran::parser::OmpAtomicClauseList>) {
-        ompClause = std::get_if<Fortran::parser::OmpClause>(&clause.u);
+      const parser::OmpClause *ompClause = nullptr;
+      if constexpr (std::is_same_v<D, const parser::OmpAtomicClauseList>) {
+        ompClause = std::get_if<parser::OmpClause>(&clause.u);
         if (!ompClause)
           continue;
-      } else if constexpr (std::is_same_v<D,
-                               const Fortran::parser::OmpClauseList>) {
+      } else if constexpr (std::is_same_v<D, const parser::OmpClauseList>) {
         ompClause = &clause;
       }
-      if (const Fortran::parser::OmpClause::Hint *hintClause{
-              std::get_if<Fortran::parser::OmpClause::Hint>(&ompClause->u)}) {
+      if (const parser::OmpClause::Hint *hintClause{
+              std::get_if<parser::OmpClause::Hint>(&ompClause->u)}) {
         std::optional<std::int64_t> hintValue = GetIntValue(hintClause->v);
         if (hintValue && *hintValue >= 0) {
           /*`omp_sync_hint_nonspeculative` and `omp_lock_hint_speculative`*/
@@ -793,7 +791,7 @@ void OmpStructureChecker::CheckSIMDNest(const parser::OpenMPConstruct &c) {
   // TODO: Check for declare simd regions.
   bool eligibleSIMD{false};
   common::visit(
-      Fortran::common::visitors{
+      common::visitors{
           // Allow `!$OMP ORDERED SIMD`
           [&](const parser::OpenMPBlockConstruct &c) {
             const auto &beginBlockDir{
@@ -2121,7 +2119,7 @@ void OmpStructureChecker::CheckCancellationNest(
         eligibleCancellation = true;
       }
       break;
-    case Fortran::parser::OmpCancelType::Type::Do:
+    case parser::OmpCancelType::Type::Do:
       if (llvm::omp::nestedCancelDoAllowedSet.test(
               GetContextParent().directive)) {
         eligibleCancellation = true;
@@ -2162,7 +2160,7 @@ void OmpStructureChecker::CheckCancellationNest(
           parser::ToUpperCaseLetters(
               parser::OmpCancelType::EnumToString(type)));
       break;
-    case Fortran::parser::OmpCancelType::Type::Do:
+    case parser::OmpCancelType::Type::Do:
       context_.Say(source,
           "%s %s directive is not closely nested inside "
           "the construct that matches the DO clause type"_err_en_US,
@@ -2228,9 +2226,9 @@ inline void OmpStructureChecker::ErrIfAllocatableVariable(
         const auto &designator =
             std::get<common::Indirection<parser::Designator>>(var.u);
         const auto *dataRef =
-            std::get_if<Fortran::parser::DataRef>(&designator.value().u);
-        const Fortran::parser::Name *name =
-            dataRef ? std::get_if<Fortran::parser::Name>(&dataRef->u) : nullptr;
+            std::get_if<parser::DataRef>(&designator.value().u);
+        const parser::Name *name =
+            dataRef ? std::get_if<parser::Name>(&dataRef->u) : nullptr;
         if (name)
           context_.Say(name->source,
               "%s must not have ALLOCATABLE "
@@ -2250,10 +2248,8 @@ inline void OmpStructureChecker::ErrIfLHSAndRHSSymbolsMatch(
     const Symbol &varSymbol = vSyms.front();
     for (const Symbol &symbol : evaluate::GetSymbolVector(*e)) {
       if (varSymbol == symbol) {
-        const Fortran::common::Indirection<Fortran::parser::Designator>
-            *designator = std::get_if<
-                Fortran::common::Indirection<Fortran::parser::Designator>>(
-                &expr.u);
+        const common::Indirection<parser::Designator> *designator =
+            std::get_if<common::Indirection<parser::Designator>>(&expr.u);
         if (designator) {
           auto *z{var.typedExpr.get()};
           auto *c{expr.typedExpr.get()};
@@ -2334,10 +2330,9 @@ void OmpStructureChecker::CheckAtomicCaptureStmt(
       common::visitors{
           [&](const common::Indirection<parser::Designator> &designator) {
             const auto *dataRef =
-                std::get_if<Fortran::parser::DataRef>(&designator.value().u);
-            const auto *name = dataRef
-                ? std::get_if<Fortran::parser::Name>(&dataRef->u)
-                : nullptr;
+                std::get_if<parser::DataRef>(&designator.value().u);
+            const auto *name =
+                dataRef ? std::get_if<parser::Name>(&dataRef->u) : nullptr;
             if (name && IsAllocatable(*name->symbol))
               context_.Say(name->source,
                   "%s must not have ALLOCATABLE "
@@ -2470,23 +2465,21 @@ void OmpStructureChecker::CheckAtomicCompareConstruct(
 // TODO: Allow cond-update-stmt once compare clause is supported.
 void OmpStructureChecker::CheckAtomicCaptureConstruct(
     const parser::OmpAtomicCapture &atomicCaptureConstruct) {
-  const Fortran::parser::AssignmentStmt &stmt1 =
-      std::get<Fortran::parser::OmpAtomicCapture::Stmt1>(
-          atomicCaptureConstruct.t)
+  const parser::AssignmentStmt &stmt1 =
+      std::get<parser::OmpAtomicCapture::Stmt1>(atomicCaptureConstruct.t)
           .v.statement;
-  const auto &stmt1Var{std::get<Fortran::parser::Variable>(stmt1.t)};
-  const auto &stmt1Expr{std::get<Fortran::parser::Expr>(stmt1.t)};
+  const auto &stmt1Var{std::get<parser::Variable>(stmt1.t)};
+  const auto &stmt1Expr{std::get<parser::Expr>(stmt1.t)};
 
-  const Fortran::parser::AssignmentStmt &stmt2 =
-      std::get<Fortran::parser::OmpAtomicCapture::Stmt2>(
-          atomicCaptureConstruct.t)
+  const parser::AssignmentStmt &stmt2 =
+      std::get<parser::OmpAtomicCapture::Stmt2>(atomicCaptureConstruct.t)
           .v.statement;
-  const auto &stmt2Var{std::get<Fortran::parser::Variable>(stmt2.t)};
-  const auto &stmt2Expr{std::get<Fortran::parser::Expr>(stmt2.t)};
+  const auto &stmt2Var{std::get<parser::Variable>(stmt2.t)};
+  const auto &stmt2Expr{std::get<parser::Expr>(stmt2.t)};
 
-  if (Fortran::semantics::checkForSingleVariableOnRHS(stmt1)) {
+  if (semantics::checkForSingleVariableOnRHS(stmt1)) {
     CheckAtomicCaptureStmt(stmt1);
-    if (Fortran::semantics::checkForSymbolMatch(stmt2)) {
+    if (semantics::checkForSymbolMatch(stmt2)) {
       // ATOMIC CAPTURE construct is of the form [capture-stmt, update-stmt]
       CheckAtomicUpdateStmt(stmt2);
     } else {
@@ -2500,8 +2493,8 @@ void OmpStructureChecker::CheckAtomicCaptureConstruct(
           "Captured variable/array element/derived-type component %s expected to be assigned in the second statement of ATOMIC CAPTURE construct"_err_en_US,
           stmt1Expr.source);
     }
-  } else if (Fortran::semantics::checkForSymbolMatch(stmt1) &&
-      Fortran::semantics::checkForSingleVariableOnRHS(stmt2)) {
+  } else if (semantics::checkForSymbolMatch(stmt1) &&
+      semantics::checkForSingleVariableOnRHS(stmt2)) {
     // ATOMIC CAPTURE construct is of the form [update-stmt, capture-stmt]
     CheckAtomicUpdateStmt(stmt1);
     CheckAtomicCaptureStmt(stmt2);
@@ -2524,28 +2517,28 @@ void OmpStructureChecker::CheckAtomicMemoryOrderClause(
     const parser::OmpAtomicClauseList *rightHandClauseList) {
   int numMemoryOrderClause{0};
   int numFailClause{0};
-  auto checkForValidMemoryOrderClause =
-      [&](const parser::OmpAtomicClauseList *clauseList) {
-        for (const auto &clause : clauseList->v) {
-          if (std::get_if<parser::OmpFailClause>(&clause.u)) {
-            numFailClause++;
-            if (numFailClause > 1) {
-              context_.Say(clause.source,
-                  "More than one FAIL clause not allowed on OpenMP ATOMIC construct"_err_en_US);
-              return;
-            }
-          } else {
-            if (std::get_if<Fortran::parser::OmpMemoryOrderClause>(&clause.u)) {
-              numMemoryOrderClause++;
-              if (numMemoryOrderClause > 1) {
-                context_.Say(clause.source,
-                    "More than one memory order clause not allowed on OpenMP ATOMIC construct"_err_en_US);
-                return;
-              }
-            }
+  auto checkForValidMemoryOrderClause = [&](const parser::OmpAtomicClauseList
+                                                *clauseList) {
+    for (const auto &clause : clauseList->v) {
+      if (std::get_if<parser::OmpFailClause>(&clause.u)) {
+        numFailClause++;
+        if (numFailClause > 1) {
+          context_.Say(clause.source,
+              "More than one FAIL clause not allowed on OpenMP ATOMIC construct"_err_en_US);
+          return;
+        }
+      } else {
+        if (std::get_if<parser::OmpMemoryOrderClause>(&clause.u)) {
+          numMemoryOrderClause++;
+          if (numMemoryOrderClause > 1) {
+            context_.Say(clause.source,
+                "More than one memory order clause not allowed on OpenMP ATOMIC construct"_err_en_US);
+            return;
           }
         }
-      };
+      }
+    }
+  };
   if (leftHandClauseList) {
     checkForValidMemoryOrderClause(leftHandClauseList);
   }