[Flang][OpenMP] NFC: Change a few message/comments to fit 80chars Changes are all in the OpenMP semantic checks file.

[SBallantyne]

LGTM

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

bool Pre(const parser::CycleStmt &cyclestmt) {
     std::map<std::string, std::int64_t>::iterator it;
     bool err{false};
     if (cyclestmt.v) {
       it = labelNamesandLevels_.find(cyclestmt.v->source.ToString());
       err = (it != labelNamesandLevels_.end() && it->second > 0);
     }
     if (cycleLevel_ > 0 || err) {
       context_.Say(*cycleSource_,
-          "CYCLE statement to non-innermost associated loop of an OpenMP DO construct"_err_en_US);
+          "CYCLE statement to non-innermost associated loop of an OpenMP DO "
+          "construct"_err_en_US);
     }
     return true;
   }
 
   bool Pre(const parser::Statement<parser::ActionStmt> &actionstmt) {
     cycleSource_ = &actionstmt.source;
     return true;
   }
if (!CurrentDirectiveIsNested()) {
       // `distribute` region has to be strictly nested inside `teams`
       if (!llvm::omp::teamSet.test(GetContextParent().directive)) {
         violation = true;
       }
     }
   }
   if (violation) {
     context_.Say(beginDir.source,
-        "`DISTRIBUTE` region has to be strictly nested inside `TEAMS` region."_err_en_US);
+        "`DISTRIBUTE` region has to be strictly nested inside `TEAMS` "
+        "region."_err_en_US);
   }
 }
 
 void OmpStructureChecker::HasInvalidTeamsNesting(
     const llvm::omp::Directive &dir, const parser::CharBlock &source) {
   OmpDirectiveSet allowedSet{llvm::omp::Directive::OMPD_parallel,
       llvm::omp::Directive::OMPD_parallel_do,
       llvm::omp::Directive::OMPD_parallel_do_simd,
       llvm::omp::Directive::OMPD_parallel_for,
       llvm::omp::Directive::OMPD_parallel_for_simd,
       llvm::omp::Directive::OMPD_parallel_master,
       llvm::omp::Directive::OMPD_parallel_master_taskloop,
       llvm::omp::Directive::OMPD_parallel_master_taskloop_simd,
       llvm::omp::Directive::OMPD_parallel_sections,
       llvm::omp::Directive::OMPD_parallel_workshare,
       llvm::omp::Directive::OMPD_distribute,
       llvm::omp::Directive::OMPD_distribute_parallel_do,
       llvm::omp::Directive::OMPD_distribute_parallel_do_simd,
       llvm::omp::Directive::OMPD_distribute_parallel_for,
       llvm::omp::Directive::OMPD_distribute_parallel_for_simd,
       llvm::omp::Directive::OMPD_distribute_simd};
 
   if (!allowedSet.test(dir)) {
     context_.Say(source,
-        "Only `DISTRIBUTE` or `PARALLEL` regions are allowed to be strictly nested inside `TEAMS` region."_err_en_US);
+        "Only `DISTRIBUTE` or `PARALLEL` regions are allowed to be strictly "
+        "nested inside `TEAMS` region."_err_en_US);
   }
 }
 
 void OmpStructureChecker::CheckPredefinedAllocatorRestriction(
     const parser::CharBlock &source, const parser::Name &name) {
   if (const auto *symbol{name.symbol}) {
     const auto *commonBlock{FindCommonBlockContaining(*symbol)};
     const auto &scope{context_.FindScope(symbol->name())};
for (const auto &clause : clauseList->v) {
                                const Fortran::parser::OmpClauseList>) {
         ompClause = &clause;
       }
       if (const Fortran::parser::OmpClause::Hint *
           hintClause{
               std::get_if<Fortran::parser::OmpClause::Hint>(&ompClause->u)}) {
         std::optional<std::int64_t> hintValue = GetIntValue(hintClause->v);
         if (hintValue && *hintValue >= 0) {
-          if((*hintValue & 0xC) == 0xC /*`omp_sync_hint_nonspeculative` and `omp_lock_hint_speculative`*/ 
-                  || (*hintValue & 0x3) == 0x3 /*`omp_sync_hint_uncontended` and omp_sync_hint_contended*/ )
+          /*`omp_sync_hint_nonspeculative` and `omp_lock_hint_speculative`*/
+          if ((*hintValue & 0xC) == 0xC
+              /*`omp_sync_hint_uncontended` and omp_sync_hint_contended*/
+              || (*hintValue & 0x3) == 0x3)
             context_.Say(clause.source,
                 "Hint clause value "
                 "is not a valid OpenMP synchronization value"_err_en_US);
         } else {
           context_.Say(clause.source,
               "Hint clause must have non-negative constant "
               "integer expression"_err_en_US);
         }
common::visit(Fortran::common::visitors{
                       eligibleSIMD = true;
                     },
                     [&](const auto &c) {},
                 },
       c.u);
   if (!eligibleSIMD) {
     context_.Say(parser::FindSourceLocation(c),
         "The only OpenMP constructs that can be encountered during execution "
-        "of a 'SIMD'"
-        " region are the `ATOMIC` construct, the `LOOP` construct, the `SIMD`"
-        " construct and the `ORDERED` construct with the `SIMD` clause."_err_en_US);
+        "of a 'SIMD' region are the `ATOMIC` construct, the `LOOP` construct, "
+        "the `SIMD` construct and the `ORDERED` construct with the `SIMD` "
+        "clause."_err_en_US);
   }
 }
 
 void OmpStructureChecker::CheckTargetNest(const parser::OpenMPConstruct &c) {
   // 2.12.5 Target Construct Restriction
   bool eligibleTarget{true};
   llvm::omp::Directive ineligibleTargetDir;
   common::visit(
if (const auto &loopConstruct{
                                  : nullptr;
       }
     }
 
     // Show error for the remaining variables
     for (auto var : indexVars) {
       const Symbol &root{GetAssociationRoot(var)};
       context_.Say(parser::FindSourceLocation(x),
-          "Variable '%s' not allowed in `LINEAR` clause, only loop iterator can be specified in `LINEAR` clause of a construct combined with `DISTRIBUTE`"_err_en_US,
+          "Variable '%s' not allowed in `LINEAR` clause, only loop iterator "
+          "can be specified in `LINEAR` clause of a construct combined with "
+          "`DISTRIBUTE`"_err_en_US,
           root.name());
     }
   }
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPLoopConstruct &) {
   if (llvm::omp::simdSet.test(GetContext().directive)) {
     ExitDirectiveNest(SIMDNest);
common::visit(
                           "directive"_err_en_US,
                           ContextDirectiveAsFortran());
                     } else if (!IsSave(*name->symbol) &&
                         declScope.kind() != Scope::Kind::MainProgram &&
                         declScope.kind() != Scope::Kind::Module) {
                       context_.Say(name->source,
                           "A variable that appears in a %s directive must be "
                           "declared in the scope of a module or have the SAVE "
-                          "attribute, either explicitly or implicitly"_err_en_US,
+                          "attribute, either explicitly or "
+                          "implicitly"_err_en_US,
                           ContextDirectiveAsFortran());
                     } else if (useScope != declScope) {
                       context_.Say(name->source,
                           "The %s directive and the common block or variable "
                           "in it must appear in the same declaration section "
                           "of a scoping unit"_err_en_US,
                           ContextDirectiveAsFortran());
                     }
context_
             parser::MessageFormattedText{
                 "CRITICAL directive names do not match"_err_en_US})
         .Attach(endDirName->source, "should be NULL"_en_US);
   }
   if (!dirName && !ompClause.source.empty() &&
       ompClause.source.NULTerminatedToString() != "hint(omp_sync_hint_none)") {
     context_.Say(dir.source,
         parser::MessageFormattedText{
-            "Hint clause other than omp_sync_hint_none cannot be specified for an unnamed CRITICAL directive"_err_en_US});
+            "Hint clause other than omp_sync_hint_none cannot be specified for "
+            "an unnamed CRITICAL directive"_err_en_US});
   }
   CheckHintClause<const parser::OmpClauseList>(&ompClause, nullptr);
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPCriticalConstruct &) {
   dirContext_.pop_back();
 }
 
common::visit(
                     "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);
+                  "Invalid operator in OpenMP ATOMIC (UPDATE) "
+                  "statement"_err_en_US);
             }
           },
       },
       expr.u);
 }
 
 void OmpStructureChecker::CheckAtomicMemoryOrderClause(
     const parser::OmpAtomicClauseList *leftHandClauseList,
common::visit(
             const parser::Name *name{std::get_if<parser::Name>(&procD.u)};
             if (name) {
               if (name->source == "max" || name->source == "min" ||
                   name->source == "iand" || name->source == "ior" ||
                   name->source == "ieor") {
                 ok = true;
               } else {
                 context_.Say(GetContext().clauseSource,
-                    "Invalid reduction identifier in REDUCTION clause."_err_en_US,
+                    "Invalid reduction identifier in REDUCTION "
+                    "clause."_err_en_US,
                     ContextDirectiveAsFortran());
               }
             }
           },
       },
       definedOp.u);
 
   return ok;
 }
 bool OmpStructureChecker::CheckIntrinsicOperator(
     const parser::DefinedOperator::IntrinsicOperator &op) {
 
   switch (op) {
   case parser::DefinedOperator::IntrinsicOperator::Add:
   case parser::DefinedOperator::IntrinsicOperator::Multiply:
   case parser::DefinedOperator::IntrinsicOperator::AND:
   case parser::DefinedOperator::IntrinsicOperator::OR:
   case parser::DefinedOperator::IntrinsicOperator::EQV:
   case parser::DefinedOperator::IntrinsicOperator::NEQV:
     return true;
   case parser::DefinedOperator::IntrinsicOperator::Subtract:
     context_.Say(GetContext().clauseSource,
-        "The minus reduction operator is deprecated since OpenMP 5.2 and is not supported in the REDUCTION clause."_err_en_US,
+        "The minus reduction operator is deprecated since OpenMP 5.2 and is "
+        "not supported in the REDUCTION clause."_err_en_US,
         ContextDirectiveAsFortran());
     break;
   default:
     context_.Say(GetContext().clauseSource,
         "Invalid reduction operator in REDUCTION clause."_err_en_US,
         ContextDirectiveAsFortran());
   }
   return false;
for (auto it : enclosingContext->clauseInfo) {
                   if (const auto *rname{
                           parser::Unwrap<parser::Name>(redOmpObject)}) {
                     if (const auto *rsymbol{rname->symbol}) {
                       if (rsymbol->name() == symbol->name()) {
                         context_.Say(GetContext().clauseSource,
                             "%s variable '%s' is %s in outer context must"
                             " be shared in the parallel regions to which any"
                             " of the worksharing regions arising from the "
-                            "worksharing"
-                            " construct bind."_err_en_US,
+                            "worksharing construct bind."_err_en_US,
                             parser::ToUpperCaseLetters(
                                 getClauseName(llvm::omp::Clause::OMPC_reduction)
                                     .str()),
                             symbol->name(),
                             parser::ToUpperCaseLetters(
                                 getClauseName(type).str()));
                       }
                     }
for (const auto &subscript : arrayElement.subscripts) {
                       "Stride should not be specified for array section in "
                       "DEPEND "
                       "clause"_err_en_US);
                 }
                 const auto stride{GetIntValue(strideExpr)};
                 if ((stride && stride != 1)) {
                   context_.Say(GetContext().clauseSource,
                       "A list item that appears in a REDUCTION clause"
-                      " should have a contiguous storage array section."_err_en_US,
+                      " should have a contiguous storage array "
+                      "section."_err_en_US,
                       ContextDirectiveAsFortran());
                   break;
                 }
               }
             }
           }
         }
       }