[NFC][flang][OpenMP] Fixes formatting issues with D110714

[NimishMishra]

Summary

This NFC fixes formatting issues introduced with https://reviews.llvm.org/D110714

[peixin]

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

1348

Please check other code. This should be like the following (if not exceeding 80 columns):

"Atomic update variable '%s' not found in the RHS of the assignment "
"statement in an ATOMIC (UPDATE) construct"_err_en_US, variableName);

[shraiysh]

LGTM

[NimishMishra]

@peixin The patch is ready for review. @shraiysh and I discussed on the reasons why clang-format checks passed on the previous patch. We think this might be a bug with clang-format that it didn't automatically break a >80 column string into two shorter strings (neither threw clang-format check failures while running checks).

[peixin]

LGTM

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

bool OmpStructureChecker::IsOperatorValid(const T &node, const D &variable) {
 
   if constexpr (common::HasMember<T, BinaryOperators>) {
     const auto &variableName{variable.GetSource().ToString()};
     const auto &exprLeft{std::get<0>(node.t)};
     const auto &exprRight{std::get<1>(node.t)};
     if ((exprLeft.value().source.ToString() != variableName) &&
         (exprRight.value().source.ToString() != variableName)) {
       context_.Say(variable.GetSource(),
-          "Atomic update variable '%s' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct"_err_en_US,
+          "Atomic update variable '%s' not found in the RHS of the \
+assignment statement in an ATOMIC (UPDATE) construct"_err_en_US,
           variableName);
     }
     return common::HasMember<T, AllowedBinaryOperators>;
   }
   return true;
 }
 
 void OmpStructureChecker::CheckAtomicUpdateAssignmentStmt(
     const parser::AssignmentStmt &assignment) {
   const auto &expr{std::get<parser::Expr>(assignment.t)};
   const auto &var{std::get<parser::Variable>(assignment.t)};
   std::visit(
       common::visitors{
           [&](const common::Indirection<parser::FunctionReference> &x) {
             const auto &procedureDesignator{
                 std::get<parser::ProcedureDesignator>(x.value().v.t)};
             const parser::Name *name{
                 std::get_if<parser::Name>(&procedureDesignator.u)};
             if (name &&
                 !(name->source == "max" || name->source == "min" ||
                     name->source == "iand" || name->source == "ior" ||
                     name->source == "ieor")) {
-              context_.Say(expr.source,
-                  "Invalid intrinsic procedure name in OpenMP ATOMIC (UPDATE) statement"_err_en_US);
+              context_.Say(expr.source, "Invalid intrinsic procedure name in \
+OpenMP ATOMIC (UPDATE) statement"_err_en_US);
             } else if (name) {
               bool foundMatch{false};
               if (auto varDesignatorIndirection =
                       std::get_if<Fortran::common::Indirection<
                           Fortran::parser::Designator>>(&var.u)) {
                 const auto &varDesignator = varDesignatorIndirection->value();
                 if (const auto *dataRef = std::get_if<Fortran::parser::DataRef>(
                         &varDesignator.u)) {
OpenMP ATOMIC (UPDATE) statement"_err_en_US);
                         }
                       }
                     }
                   }
                 }
               }
               if (!foundMatch) {
                 context_.Say(expr.source,
-                    "Atomic update variable '%s' not found in the argument list of intrinsic procedure"_err_en_US,
+                    "Atomic update variable '%s' not found in the \
+argument list of intrinsic procedure"_err_en_US,
                     var.GetSource().ToString());
               }
             }
           },
           [&](const auto &x) {
             if (!IsOperatorValid(x, var)) {
               context_.Say(expr.source,
                   "Invalid operator in OpenMP ATOMIC (UPDATE) statement"_err_en_US);
             }
           },
       },
       expr.u);
 }
 
 void OmpStructureChecker::CheckAtomicMemoryOrderClause(
     const parser::OmpAtomicClauseList &clauseList) {
   int numMemoryOrderClause = 0;
   for (const auto &clause : clauseList.v) {
     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);
+            "More than one memory order clause not allowed on OpenMP \
+Atomic construct"_err_en_US);
         return;
       }
     }
   }
 }
 
 void OmpStructureChecker::CheckAtomicMemoryOrderClause(
     const parser::OmpAtomicClauseList &leftHandClauseList,
     const parser::OmpAtomicClauseList &rightHandClauseList) {
   int numMemoryOrderClause = 0;
   for (const auto &clause : leftHandClauseList.v) {
     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);
+        context_.Say(
+            clause.source, "More than one memory order clause not allowed on \
+OpenMP Atomic construct"_err_en_US);
         return;
       }
     }
   }
   for (const auto &clause : rightHandClauseList.v) {
     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);
+        context_.Say(clause.source, "More than one memory order clause not \
+allowed on OpenMP Atomic construct"_err_en_US);
         return;
       }
     }
   }
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPAtomicConstruct &x) {
   std::visit(