[Flang] Switch to common::visit more call sites

flang/include/flang/Evaluate/tools.h

@@ -450,12 +450,12 @@ struct ExtractSubstringHelper {
 
   template <typename T>
   static std::optional<Substring> visit(const Designator<T> &e) {
-    return std::visit([](auto &&s) { return visit(s); }, e.u);
+    return common::visit([](auto &&s) { return visit(s); }, e.u);
   }
 
   template <typename T>
   static std::optional<Substring> visit(const Expr<T> &e) {
-    return std::visit([](auto &&s) { return visit(s); }, e.u);
+    return common::visit([](auto &&s) { return visit(s); }, e.u);
   }
 };
 

flang/include/flang/Lower/DumpEvaluateExpr.h

@@ -68,7 +68,7 @@ class DumpEvaluateExpr {
   }
   template <typename... A>
   void show(const std::variant<A...> &u) {
-    std::visit([&](const auto &v) { show(v); }, u);
+    Fortran::common::visit([&](const auto &v) { show(v); }, u);
   }
   template <typename A>
   void show(const std::vector<A> &x) {

flang/include/flang/Lower/PFTBuilder.h

@@ -76,7 +76,7 @@ class ReferenceVariantBase {
   }
   template <typename VISITOR>
   constexpr auto visit(VISITOR &&visitor) const {
-    return std::visit(
+    return Fortran::common::visit(
         common::visitors{[&visitor](auto ref) { return visitor(ref.get()); }},
         u);
   }
@@ -494,7 +494,8 @@ struct Variable {
 
   /// Is this variable a global?
   bool isGlobal() const {
-    return std::visit([](const auto &x) { return x.isGlobal(); }, var);
+    return Fortran::common::visit([](const auto &x) { return x.isGlobal(); },
+                                  var);
   }
 
   /// Is this a module or submodule variable?
@@ -504,7 +505,7 @@ struct Variable {
   }
 
   const Fortran::semantics::Scope *getOwningScope() const {
-    return std::visit(
+    return Fortran::common::visit(
         common::visitors{
             [](const Nominal &x) { return &x.symbol->GetUltimate().owner(); },
             [](const AggregateStore &agg) { return &agg.getOwningScope(); }},

flang/include/flang/Lower/Support/Utils.h

@@ -69,7 +69,8 @@ static Fortran::lower::SomeExpr ignoreEvConvert(const A &x) {
 inline Fortran::lower::SomeExpr
 ignoreEvConvert(const Fortran::evaluate::Expr<Fortran::evaluate::Type<
                     Fortran::common::TypeCategory::Integer, 8>> &x) {
-  return std::visit([](const auto &v) { return ignoreEvConvert(v); }, x.u);
+  return Fortran::common::visit(
+      [](const auto &v) { return ignoreEvConvert(v); }, x.u);
 }
 
 /// Zip two containers of the same size together and flatten the pairs. `flatZip
@@ -119,7 +120,8 @@ class HashEvaluateExpr {
     return 0u;
   }
   static unsigned getHashValue(const Fortran::evaluate::Subscript &x) {
-    return std::visit([&](const auto &v) { return getHashValue(v); }, x.u);
+    return Fortran::common::visit(
+        [&](const auto &v) { return getHashValue(v); }, x.u);
   }
   static unsigned getHashValue(const Fortran::evaluate::Triplet &x) {
     return getHashValue(x.lower()) - getHashValue(x.upper()) * 5u -
@@ -154,7 +156,8 @@ class HashEvaluateExpr {
     return getHashValue(x.GetComponent()) * 13u;
   }
   static unsigned getHashValue(const Fortran::evaluate::DataRef &x) {
-    return std::visit([&](const auto &v) { return getHashValue(v); }, x.u);
+    return Fortran::common::visit(
+        [&](const auto &v) { return getHashValue(v); }, x.u);
   }
   static unsigned getHashValue(const Fortran::evaluate::ComplexPart &x) {
     return getHashValue(x.complex()) - static_cast<unsigned>(x.part());
@@ -247,8 +250,9 @@ class HashEvaluateExpr {
     return getHashValue(sym.get());
   }
   static unsigned getHashValue(const Fortran::evaluate::Substring &x) {
-    return 61u * std::visit([&](const auto &p) { return getHashValue(p); },
-                            x.parent()) -
+    return 61u *
+               Fortran::common::visit(
+                   [&](const auto &p) { return getHashValue(p); }, x.parent()) -
            getHashValue(x.lower()) - (getHashValue(x.lower()) + 1u);
   }
   static unsigned
@@ -270,7 +274,8 @@ class HashEvaluateExpr {
   }
   static unsigned
   getHashValue(const Fortran::evaluate::ProcedureDesignator &x) {
-    return std::visit([&](const auto &v) { return getHashValue(v); }, x.u);
+    return Fortran::common::visit(
+        [&](const auto &v) { return getHashValue(v); }, x.u);
   }
   static unsigned getHashValue(const Fortran::evaluate::ProcedureRef &x) {
     unsigned args = 13u;
@@ -321,15 +326,18 @@ class HashEvaluateExpr {
   }
   template <typename A>
   static unsigned getHashValue(const Fortran::evaluate::Expr<A> &x) {
-    return std::visit([&](const auto &v) { return getHashValue(v); }, x.u);
+    return Fortran::common::visit(
+        [&](const auto &v) { return getHashValue(v); }, x.u);
   }
   static unsigned getHashValue(
       const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &x) {
-    return std::visit([&](const auto &v) { return getHashValue(v); }, x.u);
+    return Fortran::common::visit(
+        [&](const auto &v) { return getHashValue(v); }, x.u);
   }
   template <typename A>
   static unsigned getHashValue(const Fortran::evaluate::Designator<A> &x) {
-    return std::visit([&](const auto &v) { return getHashValue(v); }, x.u);
+    return Fortran::common::visit(
+        [&](const auto &v) { return getHashValue(v); }, x.u);
   }
   template <int BITS>
   static unsigned
@@ -378,7 +386,7 @@ class IsEqualEvaluateExpr {
   }
   static bool isEqual(const Fortran::evaluate::Subscript &x,
                       const Fortran::evaluate::Subscript &y) {
-    return std::visit(
+    return Fortran::common::visit(
         [&](const auto &v, const auto &w) { return isEqual(v, w); }, x.u, y.u);
   }
   static bool isEqual(const Fortran::evaluate::Triplet &x,
@@ -411,7 +419,7 @@ class IsEqualEvaluateExpr {
   }
   static bool isEqual(const Fortran::evaluate::DataRef &x,
                       const Fortran::evaluate::DataRef &y) {
-    return std::visit(
+    return Fortran::common::visit(
         [&](const auto &v, const auto &w) { return isEqual(v, w); }, x.u, y.u);
   }
   static bool isEqual(const Fortran::evaluate::ComplexPart &x,
@@ -499,7 +507,7 @@ class IsEqualEvaluateExpr {
   }
   static bool isEqual(const Fortran::evaluate::Substring &x,
                       const Fortran::evaluate::Substring &y) {
-    return std::visit(
+    return Fortran::common::visit(
                [&](const auto &p, const auto &q) { return isEqual(p, q); },
                x.parent(), y.parent()) &&
            isEqual(x.lower(), y.lower()) && isEqual(x.upper(), y.upper());
@@ -529,7 +537,7 @@ class IsEqualEvaluateExpr {
   }
   static bool isEqual(const Fortran::evaluate::ProcedureDesignator &x,
                       const Fortran::evaluate::ProcedureDesignator &y) {
-    return std::visit(
+    return Fortran::common::visit(
         [&](const auto &v, const auto &w) { return isEqual(v, w); }, x.u, y.u);
   }
   static bool isEqual(const Fortran::evaluate::ProcedureRef &x,
@@ -591,19 +599,19 @@ class IsEqualEvaluateExpr {
   template <typename A>
   static bool isEqual(const Fortran::evaluate::Expr<A> &x,
                       const Fortran::evaluate::Expr<A> &y) {
-    return std::visit(
+    return Fortran::common::visit(
         [&](const auto &v, const auto &w) { return isEqual(v, w); }, x.u, y.u);
   }
   static bool
   isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &x,
           const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &y) {
-    return std::visit(
+    return Fortran::common::visit(
         [&](const auto &v, const auto &w) { return isEqual(v, w); }, x.u, y.u);
   }
   template <typename A>
   static bool isEqual(const Fortran::evaluate::Designator<A> &x,
                       const Fortran::evaluate::Designator<A> &y) {
-    return std::visit(
+    return Fortran::common::visit(
         [&](const auto &v, const auto &w) { return isEqual(v, w); }, x.u, y.u);
   }
   template <int BITS>

flang/include/flang/Optimizer/Support/Matcher.h

@@ -13,6 +13,7 @@
 #ifndef FORTRAN_OPTIMIZER_SUPPORT_MATCHER_H
 #define FORTRAN_OPTIMIZER_SUPPORT_MATCHER_H
 
+#include "flang/Common/idioms.h"
 #include <variant>
 
 // Boilerplate CRTP class for a simplified type-casing syntactic sugar. This
@@ -23,10 +24,10 @@ template<class... Ts> struct matches : Ts... { using Ts::operator()...; };
 template<class... Ts> matches(Ts...) -> matches<Ts...>;
 template<typename N> struct matcher {
   template<typename... Ts> auto match(Ts... ts) {
-    return std::visit(matches{ts...}, static_cast<N*>(this)->matchee());
+    return Fortran::common::visit(matches{ts...}, static_cast<N*>(this)->matchee());
   }
   template<typename... Ts> auto match(Ts... ts) const {
-    return std::visit(matches{ts...}, static_cast<N const*>(this)->matchee());
+    return Fortran::common::visit(matches{ts...}, static_cast<N const*>(this)->matchee());
   }
 };
 // clang-format on

flang/lib/Evaluate/intrinsics.cpp

@@ -2936,7 +2936,7 @@ static bool CheckForNonPositiveValues(FoldingContext &context,
   if (arg.Rank() > 0) {
     if (const Expr<SomeType> *expr{arg.UnwrapExpr()}) {
       if (const auto *intExpr{std::get_if<Expr<SomeInteger>>(&expr->u)}) {
-        std::visit(
+        Fortran::common::visit(
             [&](const auto &kindExpr) {
               using IntType = typename std::decay_t<decltype(kindExpr)>::Result;
               if (const auto *constArray{

flang/lib/Lower/Allocatable.cpp

@@ -350,10 +350,10 @@ class AllocateStmtHelper {
   void visitAllocateOptions() {
     for (const auto &allocOption :
          std::get<std::list<Fortran::parser::AllocOpt>>(stmt.t))
-      std::visit(
+      Fortran::common::visit(
           Fortran::common::visitors{
               [&](const Fortran::parser::StatOrErrmsg &statOrErr) {
-                std::visit(
+                Fortran::common::visit(
                     Fortran::common::visitors{
                         [&](const Fortran::parser::StatVariable &statVar) {
                           statExpr = Fortran::semantics::GetExpr(statVar);
@@ -898,15 +898,16 @@ void Fortran::lower::genDeallocateStmt(
   const Fortran::lower::SomeExpr *errMsgExpr = nullptr;
   for (const Fortran::parser::StatOrErrmsg &statOrErr :
        std::get<std::list<Fortran::parser::StatOrErrmsg>>(stmt.t))
-    std::visit(Fortran::common::visitors{
-                   [&](const Fortran::parser::StatVariable &statVar) {
-                     statExpr = Fortran::semantics::GetExpr(statVar);
-                   },
-                   [&](const Fortran::parser::MsgVariable &errMsgVar) {
-                     errMsgExpr = Fortran::semantics::GetExpr(errMsgVar);
-                   },
-               },
-               statOrErr.u);
+    Fortran::common::visit(
+        Fortran::common::visitors{
+            [&](const Fortran::parser::StatVariable &statVar) {
+              statExpr = Fortran::semantics::GetExpr(statVar);
+            },
+            [&](const Fortran::parser::MsgVariable &errMsgVar) {
+              errMsgExpr = Fortran::semantics::GetExpr(errMsgVar);
+            },
+        },
+        statOrErr.u);
   ErrorManager errorManager;
   errorManager.init(converter, loc, statExpr, errMsgExpr);
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();