Revert "[flang][OpenMP] Avoid early returns, NFC (#117231)"

This reverts commit 1a08b15.

Buildbot failure:
https://lab.llvm.org/buildbot/#/builders/157/builds/13427

Author: kazutakahirata

flang/lib/Lower/OpenMP/Clauses.h

@@ -163,16 +163,6 @@ std::optional<ResultTy> maybeApplyToV(FuncTy &&func, const ArgTy *arg) {
   return func(arg->v);
 }
 
-template <
-    typename FuncTy, //
-    typename ArgTy,  //
-    typename ResultTy = std::invoke_result_t<FuncTy, typename ArgTy::Value>>
-std::optional<ResultTy> maybeApplyToV(FuncTy &&func, const ArgTy *arg) {
-  if (!arg)
-    return std::nullopt;
-  return std::move(func(arg->v));
-}
-
 std::optional<Object> getBaseObject(const Object &object,
                                     semantics::SemanticsContext &semaCtx);
 

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

@@ -2865,41 +2865,45 @@ void OmpStructureChecker::Enter(const parser::OmpClause::Reduction &x) {
 
 bool OmpStructureChecker::CheckReductionOperators(
     const parser::OmpClause::Reduction &x) {
-  bool ok = false;
   auto &modifiers{OmpGetModifiers(x.v)};
-  if (const auto *ident{
-          OmpGetUniqueModifier<parser::OmpReductionIdentifier>(modifiers)}) {
-
-    auto visitOperator{[&](const parser::DefinedOperator &dOpr) {
-      if (const auto *intrinsicOp{
-              std::get_if<parser::DefinedOperator::IntrinsicOperator>(
-                  &dOpr.u)}) {
-        ok = CheckIntrinsicOperator(*intrinsicOp);
-      } else {
-        context_.Say(GetContext().clauseSource,
-            "Invalid reduction operator in REDUCTION clause."_err_en_US,
-            ContextDirectiveAsFortran());
-      }
-    }};
-
-    auto visitDesignator{[&](const parser::ProcedureDesignator &procD) {
-      const parser::Name *name{std::get_if<parser::Name>(&procD.u)};
-      if (name && name->symbol) {
-        const SourceName &realName{name->symbol->GetUltimate().name()};
-        if (realName == "max" || realName == "min" || realName == "iand" ||
-            realName == "ior" || realName == "ieor") {
-          ok = true;
-        }
-      }
-      if (!ok) {
-        context_.Say(GetContext().clauseSource,
-            "Invalid reduction identifier in REDUCTION "
-            "clause."_err_en_US,
-            ContextDirectiveAsFortran());
-      }
-    }};
-    common::visit(common::visitors{visitOperator, visitDesignator}, ident->u);
+  const auto *definedOp{
+      OmpGetUniqueModifier<parser::OmpReductionIdentifier>(modifiers)};
+  if (!definedOp) {
+    return false;
   }
+  bool ok = false;
+  common::visit(
+      common::visitors{
+          [&](const parser::DefinedOperator &dOpr) {
+            if (const auto *intrinsicOp{
+                    std::get_if<parser::DefinedOperator::IntrinsicOperator>(
+                        &dOpr.u)}) {
+              ok = CheckIntrinsicOperator(*intrinsicOp);
+            } else {
+              context_.Say(GetContext().clauseSource,
+                  "Invalid reduction operator in REDUCTION clause."_err_en_US,
+                  ContextDirectiveAsFortran());
+            }
+          },
+          [&](const parser::ProcedureDesignator &procD) {
+            const parser::Name *name{std::get_if<parser::Name>(&procD.u)};
+            if (name && name->symbol) {
+              const SourceName &realName{name->symbol->GetUltimate().name()};
+              if (realName == "max" || realName == "min" ||
+                  realName == "iand" || realName == "ior" ||
+                  realName == "ieor") {
+                ok = true;
+              }
+            }
+            if (!ok) {
+              context_.Say(GetContext().clauseSource,
+                  "Invalid reduction identifier in REDUCTION "
+                  "clause."_err_en_US,
+                  ContextDirectiveAsFortran());
+            }
+          },
+      },
+      definedOp->u);
 
   return ok;
 }

flang/lib/Semantics/resolve-directives.cpp

@@ -522,47 +522,49 @@ class OmpAttributeVisitor : DirectiveAttributeVisitor<llvm::omp::Directive> {
     const auto &objList{std::get<parser::OmpObjectList>(x.v.t)};
     ResolveOmpObjectList(objList, Symbol::Flag::OmpReduction);
 
-    if (auto &modifiers{OmpGetModifiers(x.v)}) {
-      auto createDummyProcSymbol = [&](const parser::Name *name) {
-        // If name resolution failed, create a dummy symbol
-        const auto namePair{currScope().try_emplace(
-            name->source, Attrs{}, ProcEntityDetails{})};
-        auto &newSymbol{*namePair.first->second};
-        if (context_.intrinsics().IsIntrinsic(name->ToString())) {
-          newSymbol.attrs().set(Attr::INTRINSIC);
-        }
-        name->symbol = &newSymbol;
-      };
+    auto &modifiers{OmpGetModifiers(x.v)};
+    if (!modifiers) {
+      return false;
+    }
 
-      for (auto &mod : *modifiers) {
-        if (!std::holds_alternative<parser::OmpReductionIdentifier>(mod.u)) {
-          continue;
-        }
-        auto &opr{std::get<parser::OmpReductionIdentifier>(mod.u)};
-        if (auto *procD{parser::Unwrap<parser::ProcedureDesignator>(opr.u)}) {
-          if (auto *name{parser::Unwrap<parser::Name>(procD->u)}) {
-            if (!name->symbol) {
-              if (!ResolveName(name)) {
-                createDummyProcSymbol(name);
-              }
+    auto createDummyProcSymbol = [&](const parser::Name *name) {
+      // If name resolution failed, create a dummy symbol
+      const auto namePair{
+          currScope().try_emplace(name->source, Attrs{}, ProcEntityDetails{})};
+      auto &newSymbol{*namePair.first->second};
+      if (context_.intrinsics().IsIntrinsic(name->ToString())) {
+        newSymbol.attrs().set(Attr::INTRINSIC);
+      }
+      name->symbol = &newSymbol;
+    };
+
+    for (auto &mod : *modifiers) {
+      if (!std::holds_alternative<parser::OmpReductionIdentifier>(mod.u)) {
+        continue;
+      }
+      auto &opr{std::get<parser::OmpReductionIdentifier>(mod.u)};
+      if (auto *procD{parser::Unwrap<parser::ProcedureDesignator>(opr.u)}) {
+        if (auto *name{parser::Unwrap<parser::Name>(procD->u)}) {
+          if (!name->symbol) {
+            if (!ResolveName(name)) {
+              createDummyProcSymbol(name);
             }
           }
-          if (auto *procRef{
-                  parser::Unwrap<parser::ProcComponentRef>(procD->u)}) {
-            if (!procRef->v.thing.component.symbol) {
-              if (!ResolveName(&procRef->v.thing.component)) {
-                createDummyProcSymbol(&procRef->v.thing.component);
-              }
+        }
+        if (auto *procRef{parser::Unwrap<parser::ProcComponentRef>(procD->u)}) {
+          if (!procRef->v.thing.component.symbol) {
+            if (!ResolveName(&procRef->v.thing.component)) {
+              createDummyProcSymbol(&procRef->v.thing.component);
             }
           }
         }
       }
-      using ReductionModifier = parser::OmpReductionModifier;
-      if (auto *maybeModifier{
-              OmpGetUniqueModifier<ReductionModifier>(modifiers)}) {
-        if (maybeModifier->v == ReductionModifier::Value::Inscan) {
-          ResolveOmpObjectList(objList, Symbol::Flag::OmpInScanReduction);
-        }
+    }
+    using ReductionModifier = parser::OmpReductionModifier;
+    if (auto *maybeModifier{
+            OmpGetUniqueModifier<ReductionModifier>(modifiers)}) {
+      if (maybeModifier->v == ReductionModifier::Value::Inscan) {
+        ResolveOmpObjectList(objList, Symbol::Flag::OmpInScanReduction);
       }
     }
     return false;