[flang] Add & use a better visit()

[klausler]

Summary

Adds flang/include/flang/Common/visit.h, which defines
a Fortran::common::visit() template function that is a drop-in
replacement for std::visit(). Modifies most use sites in
the front-end and runtime to use common::visit().

The C++ standard mandates that std::visit() have O(1) execution
time, which forces implementations to build dispatch tables.
This new common::visit() is O(log2 N) in the number of alternatives
in a variant<>, but that N tends to be small and so this change
produces a fairly significant improvement in compiler build
memory requirements, a 5-10% improvement in compiler build time,
and a small improvement in compiler execution time.

Building with -DFLANG_USE_STD_VISIT causes common::visit()
to be an alias for std::visit().

Calls to common::visit() with multiple variant arguments
are referred to std::visit(), pending further work.

[klausler]

Rebased to current HEAD.

[klausler]

Scrub some changes that snuck in from another patch.

[jeanPerier]

LGTM

[jeanPerier]

Wrong button, approved.

[awarzynski]

Thanks for this patch. I will need to revert it for now as it's causing multiple buildbots to fail:

• flang-aarch64-dylib
• flang-aarch64-latest-clang
• flang-aarch64-out-of-tree
• flang-aarch64-rel-assert
• flang-aarch64-release
• flang-aarch64-sharedlibs

All of these buildbots run on AArch64 and use Clang. I can confirm that there are no issues when:

• building on X86 (tested with GCC 9.3 and Clang 12)
• building on AArch64 with GCC (tested with GCC 11)

AFAIK, there's no pre-merge CI for AArch64, but I can test this manually for you once a fix is available. One other option is to change this to "opt-in", but I'm not a fan.

[klausler]

The change could have been disabled easily in one place with a #define -- it was protected by #ifdefs. You should not have reverted all of it without consulting me. I will not waste any more time trying to push it into llvm.

[rovka]

In D122441#3411723, @klausler wrote:

The change could have been disabled easily in one place with a #define -- it was protected by #ifdefs. You should not have reverted all of it without consulting me. I will not waste any more time trying to push it into llvm.

@klausler: I can't speak for Andrzej, but I think his revert was conforming to the (admittedly aggressive) LLVM revert policy. A revert is not meant as an affront, and in general it's preferred to revert and recommit with a fix than to commit just a fix later on (this makes it easier for people to backport patches into e.g. the release branch or downstream branches without having to chase follow-up fixes). We also try really hard to bring the buildbots back to green as soon as possible, because if someone else breaks something while the bots are already red, they won't get a notification and it will be much more difficult to track down the issue (it basically means the person who committed the second red patch won't be aware that they broke something, and it will be down to the buildbot owner to notice that the CI is red and waste a lot of time trying to figure out what's going on; this also tends to get a nasty snowball effect). Because of this urgency it's considered good practice to revert someone else's patch if they don't do it themselves after some arbitrary amount of time (and especially if you know they're on a different timezone and suspect they might be offline).

TL;DR: I think this is just a misunderstanding, please don't abandon the patch because of it. My personal impression is that Andrzej was acting in good faith here, according to the norms and habits of the wider LLVM community.

[klausler]

In D122441#3413457, @rovka wrote:

TL;DR: I think this is just a misunderstanding, please don't abandon the patch because of it. My personal impression is that Andrzej was acting in good faith here, according to the norms and habits of the wider LLVM community.

The patch is not required for correctness, and I've already spent too much of my limited time on it.

[awarzynski]

Thanks Diana, this was indeed reverted in good faith. I appreciate that this can be frustrating, but with such a high traffic and so many developers working on this project, reverting is the most reliable way to address such issues in a timely fashion. @klausler, please don't abandon this patch. Given the time difference between us, it can be tricky to coordinate (IIUC, that's one of the reasons for the revert policy to be so liberal).

We did some more digging and it looks like a Clang 13 issue. On AArch64, both Clang 12 and Clang 14 are fine. I believe that @Leporacanthicus was also able to reproduce this with Clang 13 on X86.

[Leporacanthicus]

We did some more digging and it looks like a Clang 13 issue. On AArch64, both Clang 12 and Clang 14 are fine. I believe that @Leporacanthicus was also able to reproduce this with Clang 13 on X86.

I have indeed reproduced this, both an older Clang-14 (from early November, not picked for any other reason than "I happen to have it compiled") and a Clang-13 from about a year back (again, not a specific release, just "a build I had sitting around"). I stopped compiling at around 25-30 minutes of CPU time in PFTBuilder.cpp.

I suspect this is a bug in Clang (or performance issue), exposed by this change. I ran perf record clang++ ..., but it's not showing an obvious "it hangs in one function" - it may well still hang, just that it's calling many different functions within the loop that it is stuck in. I have not tried to debug using for example gdb. This has been a background task while I was working on other things, trying to help Andrzej understand the issue.

Changing the logic to disable the new visit function works fine, so one option might be to commit this with it default disabled, and add some CMake code to enable it where it is beneficial (or not exposing the bug at least). I'm not entirely sure what those conditions are, however.

I have left my machine to compile that file over night, to see if it's a genuine hang or just "takes a very long time" - if it's not finished by tomorrow morning, I'm definitely calling it a hang. I will report back tomorrow on the result of that.

[Leporacanthicus]

I have left my machine to compile that file over night, to see if it's a genuine hang or just "takes a very long time" - if it's not finished by tomorrow morning, I'm definitely calling it a hang. I will report back tomorrow on the result of that.

15h29m of CPU time later, and it still hasn't finished. I call that a hang... :)

Quick look in the debugger, it seems to be stuck in llvm::InlinerPass::run, but I've not spent any effort on figuring out why/reduce the problem

flang/include/flang/Common/idioms.h

 #endif
 #if __cplusplus < 201703L
 #error this is a C++17 program
 #endif
 #if !__clang__ && defined __GNUC__ && __GNUC__ < 7
 #error g++ >= 7.2 is required
 #endif
 
+#include "visit.h"
 #include "llvm/Support/Compiler.h"
 #include <functional>
 #include <list>
 #include <memory>
 #include <optional>
 #include <string>
 #include <tuple>
 #include <type_traits>

 #endif
 
 // enable "this is a std::string"s with the 's' suffix
 using namespace std::literals::string_literals;
 
 namespace Fortran::common {
 
 // Helper templates for combining a list of lambdas into an anonymous
-// struct for use with std::visit() on a std::variant<> sum type.
-// E.g.: std::visit(visitors{
+// struct for use with common::visit() on a std::variant<> sum type.
+// E.g.: common::visit(visitors{
 //         [&](const firstType &x) { ... },
 //         [&](const secondType &x) { ... },
 //         ...
 //         [&](const auto &catchAll) { ... }}, variantObject);
 
 template <typename... LAMBDAS> struct visitors : LAMBDAS... {
   using LAMBDAS::operator()...;
 };

flang/include/flang/Common/template.h

template <typename A> const A *GetPtrFromOptional(const std::optional<A> &x) {
   } else {
     return nullptr;
   }
 }
 
 // Copy a value from one variant type to another.  The types allowed in the
 // source variant must all be allowed in the destination variant type.
 template <typename TOV, typename FROMV> TOV CopyVariant(const FROMV &u) {
-  return std::visit([](const auto &x) -> TOV { return {x}; }, u);
+  return common::visit([](const auto &x) -> TOV { return {x}; }, u);
 }
 
 // Move a value from one variant type to another.  The types allowed in the
 // source variant must all be allowed in the destination variant type.
 template <typename TOV, typename FROMV>
 common::IfNoLvalue<TOV, FROMV> MoveVariant(FROMV &&u) {
-  return std::visit(
+  return common::visit(
       [](auto &&x) -> TOV { return {std::move(x)}; }, std::move(u));
 }
 
 // CombineTuples takes a list of std::tuple<> template instantiation types
 // and constructs a new std::tuple type that concatenates all of their member
 // types.  E.g.,
 //   CombineTuples<std::tuple<char, int>, std::tuple<float, double>>
 // is std::tuple<char, int, float, double>.

flang/include/flang/Common/unwrap.h

 //===-- include/flang/Common/unwrap.h ---------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_COMMON_UNWRAP_H_
 #define FORTRAN_COMMON_UNWRAP_H_
 
 #include "indirection.h"
 #include "reference-counted.h"
 #include "reference.h"
+#include "visit.h"
 #include <memory>
 #include <optional>
 #include <type_traits>
 #include <variant>
 
 // Given a nest of variants, optionals, &/or pointers, Unwrap<>() isolates
 // a packaged value of a specific type if it is present and returns a pointer
 // thereto; otherwise, it returns a null pointer.  It's analogous to
if (x) {
       return Unwrap<A>(*x);
     } else {
       return nullptr;
     }
   }
 
   template <typename A, typename... Bs>
   static A *Unwrap(std::variant<Bs...> &u) {
-    return std::visit(
+    return common::visit(
         [](auto &x) -> A * {
           using Ty = std::decay_t<decltype(Unwrap<A>(x))>;
           if constexpr (!std::is_const_v<std::remove_pointer_t<Ty>> ||
               std::is_const_v<A>) {
             return Unwrap<A>(x);
           }
           return nullptr;
         },
         u);
   }
 
   template <typename A, typename... Bs>
   static auto Unwrap(const std::variant<Bs...> &u) -> std::add_const_t<A> * {
-    return std::visit(
+    return common::visit(
         [](const auto &x) -> std::add_const_t<A> * { return Unwrap<A>(x); }, u);
   }
 
   template <typename A, typename B>
   static auto Unwrap(const Reference<B> &ref) -> Constify<A, B> * {
     return Unwrap<A>(*ref);
   }
 

flang/include/flang/Common/visit.h

+//===-- include/flang/Common/visit.h ----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// common::visit() is a drop-in replacement for std::visit() that reduces both
+// compiler build time and compiler execution time modestly, and reduces
+// compiler build memory requirements significantly (overall & maximum).
+// It does not require redefinition of std::variant<>.
+//
+// The C++ standard mandates that std::visit be O(1), but most variants are
+// small and O(logN) is faster in practice to compile and execute, avoiding
+// the need to build a dispatch table.
+//
+// Define FLANG_USE_STD_VISIT to avoid this code and make common::visit() an
+// alias for ::std::visit().
+//
+//
+// With GCC 9.3.0 on a Haswell x86 Ubuntu system, doing out-of-tree builds:
+// Before:
+//  build:
+//   6948.53user 212.48system 27:32.92elapsed 433%CPU
+//     (0avgtext+0avgdata 6429568maxresident)k
+//   36181912inputs+8943720outputs (3613684major+97908699minor)pagefaults 0swaps
+//  execution of tests:
+//   205.99user 26.05system 1:08.87elapsed 336%CPU
+//     (0avgtext+0avgdata 2671452maxresident)k
+//   244432inputs+355464outputs (422major+8746468minor)pagefaults 0swaps
+// After:
+//  build:
+//   6651.91user 182.57system 25:15.73elapsed 450%CPU
+//     (0avgtext+0avgdata 6209296maxresident)k
+//   17413480inputs+6376360outputs (1567210major+93068230minor)pagefaults 0swaps
+//  execution of tests:
+//   201.42user 25.91system 1:04.68elapsed 351%CPU
+//     (0avgtext+0avgdata 2661424maxresident)k
+//   238840inputs+295912outputs (428major+8489300minor)pagefaults 0swaps
+
+#ifndef FORTRAN_COMMON_VISIT_H_
+#define FORTRAN_COMMON_VISIT_H_
+
+#include <type_traits>
+#include <variant>
+
+namespace Fortran::common {
+namespace log2visit {
+
+template <std::size_t LOW, std::size_t HIGH, typename RESULT, typename VISITOR,
+    typename... VARIANT>
+inline RESULT Log2VisitHelper(
+    VISITOR &&visitor, std::size_t which, VARIANT &&...u) {
+  if constexpr (LOW == HIGH) {
+    return visitor(std::get<LOW>(std::forward<VARIANT>(u))...);
+  } else {
+    static constexpr std::size_t mid{(HIGH + LOW) / 2};
+    if (which <= mid) {
+      return Log2VisitHelper<LOW, mid, RESULT>(
+          std::forward<VISITOR>(visitor), which, std::forward<VARIANT>(u)...);
+    } else {
+      return Log2VisitHelper<(mid + 1), HIGH, RESULT>(
+          std::forward<VISITOR>(visitor), which, std::forward<VARIANT>(u)...);
+    }
+  }
+}
+
+template <typename VISITOR, typename... VARIANT>
+inline auto visit(VISITOR &&visitor, VARIANT &&...u)
+    -> decltype(visitor(std::get<0>(std::forward<VARIANT>(u))...)) {
+  using Result = decltype(visitor(std::get<0>(std::forward<VARIANT>(u))...));
+  if constexpr (sizeof...(u) == 1) {
+    static constexpr std::size_t high{
+        (std::variant_size_v<std::decay_t<decltype(u)>> * ...) - 1};
+    return Log2VisitHelper<0, high, Result>(std::forward<VISITOR>(visitor),
+        u.index()..., std::forward<VARIANT>(u)...);
+  } else {
+    // TODO: figure out how to do multiple variant arguments
+    return ::std::visit(
+        std::forward<VISITOR>(visitor), std::forward<VARIANT>(u)...);
+  }
+}
+
+} // namespace log2visit
+
+#ifdef FLANG_USE_STD_VISIT
+using ::std::visit;
+#else
+using Fortran::common::log2visit::visit;
+#endif
+
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_VISIT_H_

flang/include/flang/Evaluate/expression.h

template <> class Relational<SomeType> {
   using DirectlyComparableTypes = common::CombineTuples<IntegerTypes, RealTypes,
       ComplexTypes, CharacterTypes>;
 
 public:
   using Result = LogicalResult;
   EVALUATE_UNION_CLASS_BOILERPLATE(Relational)
   static constexpr DynamicType GetType() { return Result::GetType(); }
   int Rank() const {
-    return std::visit([](const auto &x) { return x.Rank(); }, u);
+    return common::visit([](const auto &x) { return x.Rank(); }, u);
   }
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &o) const;
   common::MapTemplate<Relational, DirectlyComparableTypes> u;
 };
 
 FOR_EACH_INTEGER_KIND(extern template class Relational, )
 FOR_EACH_REAL_KIND(extern template class Relational, )
 FOR_EACH_CHARACTER_KIND(extern template class Relational, )

flang/include/flang/Evaluate/fold-designator.h

 public:
   explicit DesignatorFolder(FoldingContext &c) : context_{c} {}
 
   bool isEmpty() const { return isEmpty_; }
   bool isOutOfRange() const { return isOutOfRange_; }
 
   template <typename T>
   std::optional<OffsetSymbol> FoldDesignator(const Expr<T> &expr) {
-    return std::visit(
+    return common::visit(
         [&](const auto &x) { return FoldDesignator(x, elementNumber_++); },
         expr.u);
   }
 
 private:
   std::optional<OffsetSymbol> FoldDesignator(const Symbol &, ConstantSubscript);
   std::optional<OffsetSymbol> FoldDesignator(
       const SymbolRef &x, ConstantSubscript which) {
private:
   std::optional<OffsetSymbol> FoldDesignator(
       const CoarrayRef &, ConstantSubscript);
   std::optional<OffsetSymbol> FoldDesignator(
       const ProcedureDesignator &, ConstantSubscript);
 
   template <typename T>
   std::optional<OffsetSymbol> FoldDesignator(
       const Expr<T> &expr, ConstantSubscript which) {
-    return std::visit(
+    return common::visit(
         [&](const auto &x) { return FoldDesignator(x, which); }, expr.u);
   }
 
   template <typename A>
   std::optional<OffsetSymbol> FoldDesignator(const A &x, ConstantSubscript) {
     return std::nullopt;
   }
 
   template <typename T>
   std::optional<OffsetSymbol> FoldDesignator(
       const Designator<T> &designator, ConstantSubscript which) {
-    return std::visit(
+    return common::visit(
         [&](const auto &x) { return FoldDesignator(x, which); }, designator.u);
   }
   template <int KIND>
   std::optional<OffsetSymbol> FoldDesignator(
       const Designator<Type<TypeCategory::Character, KIND>> &designator,
       ConstantSubscript which) {
-    return std::visit(
+    return common::visit(
         common::visitors{
             [&](const Substring &ss) {
               if (const auto *dataRef{ss.GetParentIf<DataRef>()}) {
                 if (auto result{FoldDesignator(*dataRef, which)}) {
                   if (auto start{ToInt64(ss.lower())}) {
                     std::optional<ConstantSubscript> end;
                     auto len{dataRef->LEN()};
                     if (ss.upper()) {

flang/include/flang/Evaluate/initial-image.h

if (offset < 0 || offset + bytes > data_.size()) {
       }
     }
   }
   Result Add(ConstantSubscript, std::size_t, const Constant<SomeDerived> &,
       FoldingContext &);
   template <typename T>
   Result Add(ConstantSubscript offset, std::size_t bytes, const Expr<T> &x,
       FoldingContext &c) {
-    return std::visit(
+    return common::visit(
         [&](const auto &y) { return Add(offset, bytes, y, c); }, x.u);
   }
 
   void AddPointer(ConstantSubscript, const Expr<SomeType> &);
 
   void Incorporate(ConstantSubscript toOffset, const InitialImage &from,
       ConstantSubscript fromOffset, ConstantSubscript bytes);
 

flang/include/flang/Evaluate/shape.h

private:
   static Result ScalarShape() { return Shape{}; }
   static Shape ConstantShape(const Constant<ExtentType> &);
   Result AsShape(ExtentExpr &&) const;
   static Shape CreateShape(int rank, NamedEntity &);
 
   template <typename T>
   MaybeExtentExpr GetArrayConstructorValueExtent(
       const ArrayConstructorValue<T> &value) const {
-    return std::visit(
+    return common::visit(
         common::visitors{
             [&](const Expr<T> &x) -> MaybeExtentExpr {
               if (auto xShape{
                       context_ ? GetShape(*context_, x) : GetShape(x)}) {
                 // Array values in array constructors get linearized.
                 return GetSize(std::move(*xShape));
               } else {
                 return std::nullopt;

flang/include/flang/Evaluate/tools.h

 template <typename A> bool IsAssumedRank(const Designator<A> &designator) {
   if (const auto *symbol{std::get_if<SymbolRef>(&designator.u)}) {
     return IsAssumedRank(symbol->get());
   } else {
     return false;
   }
 }
 template <typename T> bool IsAssumedRank(const Expr<T> &expr) {
-  return std::visit([](const auto &x) { return IsAssumedRank(x); }, expr.u);
+  return common::visit([](const auto &x) { return IsAssumedRank(x); }, expr.u);
 }
 template <typename A> bool IsAssumedRank(const std::optional<A> &x) {
   return x && IsAssumedRank(*x);
 }
 
 // Predicate: true when an expression is a coarray (corank > 0)
 bool IsCoarray(const ActualArgument &);
 bool IsCoarray(const Symbol &);
 template <typename A> bool IsCoarray(const A &) { return false; }
 template <typename A> bool IsCoarray(const Designator<A> &designator) {
   if (const auto *symbol{std::get_if<SymbolRef>(&designator.u)}) {
     return IsCoarray(**symbol);
   }
   return false;
 }
 template <typename T> bool IsCoarray(const Expr<T> &expr) {
-  return std::visit([](const auto &x) { return IsCoarray(x); }, expr.u);
+  return common::visit([](const auto &x) { return IsCoarray(x); }, expr.u);
 }
 template <typename A> bool IsCoarray(const std::optional<A> &x) {
   return x && IsCoarray(*x);
 }
 
 // Generalizing packagers: these take operations and expressions of more
 // specific types and wrap them in Expr<> containers of more abstract types.
 
auto UnwrapExpr(B &x) -> common::Constify<A, B> * {
   using Ty = std::decay_t<B>;
   if constexpr (std::is_same_v<A, Ty>) {
     return &x;
   } else if constexpr (std::is_same_v<Ty, ActualArgument>) {
     if (auto *expr{x.UnwrapExpr()}) {
       return UnwrapExpr<A>(*expr);
     }
   } else if constexpr (std::is_same_v<Ty, Expr<SomeType>>) {
-    return std::visit([](auto &x) { return UnwrapExpr<A>(x); }, x.u);
+    return common::visit([](auto &x) { return UnwrapExpr<A>(x); }, x.u);
   } else if constexpr (!common::HasMember<A, TypelessExpression>) {
     if constexpr (std::is_same_v<Ty, Expr<ResultType<A>>> ||
         std::is_same_v<Ty, Expr<SomeKind<ResultType<A>::category>>>) {
-      return std::visit([](auto &x) { return UnwrapExpr<A>(x); }, x.u);
+      return common::visit([](auto &x) { return UnwrapExpr<A>(x); }, x.u);
     }
   }
   return nullptr;
 }
 
 template <typename A, typename B>
 const A *UnwrapExpr(const std::optional<B> &x) {
   if (x) {
auto UnwrapConvertedExpr(B &x) -> common::Constify<A, B> * {
   using Ty = std::decay_t<B>;
   if constexpr (std::is_same_v<A, Ty>) {
     return &x;
   } else if constexpr (std::is_same_v<Ty, ActualArgument>) {
     if (auto *expr{x.UnwrapExpr()}) {
       return UnwrapConvertedExpr<A>(*expr);
     }
   } else if constexpr (std::is_same_v<Ty, Expr<SomeType>>) {
-    return std::visit([](auto &x) { return UnwrapConvertedExpr<A>(x); }, x.u);
+    return common::visit(
+        [](auto &x) { return UnwrapConvertedExpr<A>(x); }, x.u);
   } else if constexpr (!common::HasMember<A, TypelessExpression>) {
     using Result = ResultType<A>;
     if constexpr (std::is_same_v<Ty, Expr<Result>> ||
         std::is_same_v<Ty, Expr<SomeKind<Result::category>>>) {
-      return std::visit([](auto &x) { return UnwrapConvertedExpr<A>(x); }, x.u);
+      return common::visit(
+          [](auto &x) { return UnwrapConvertedExpr<A>(x); }, x.u);
     } else if constexpr (std::is_same_v<Ty, Parentheses<Result>> ||
         std::is_same_v<Ty, Convert<Result, Result::category>>) {
-      return std::visit(
+      return common::visit(
           [](auto &x) { return UnwrapConvertedExpr<A>(x); }, x.left().u);
     }
   }
   return nullptr;
 }
 
 // When an expression is a "bare" LEN= derived type parameter inquiry,
 // possibly wrapped in integer kind conversions &/or parentheses, return

 template <typename A>
 common::IfNoLvalue<std::optional<DataRef>, A> ExtractDataRef(
     const A &, bool intoSubstring) {
   return std::nullopt; // default base case
 }
 template <typename T>
 std::optional<DataRef> ExtractDataRef(
     const Designator<T> &d, bool intoSubstring = false) {
-  return std::visit(
+  return common::visit(
       [=](const auto &x) -> std::optional<DataRef> {
         if constexpr (common::HasMember<decltype(x), decltype(DataRef::u)>) {
           return DataRef{x};
         }
         if constexpr (std::is_same_v<std::decay_t<decltype(x)>, Substring>) {
           if (intoSubstring) {
             return ExtractSubstringBase(x);
           }
         }
         return std::nullopt; // w/o "else" to dodge bogus g++ 8.1 warning
       },
       d.u);
 }
 template <typename T>
 std::optional<DataRef> ExtractDataRef(
     const Expr<T> &expr, bool intoSubstring = false) {
-  return std::visit(
+  return common::visit(
       [=](const auto &x) { return ExtractDataRef(x, intoSubstring); }, expr.u);
 }
 template <typename A>
 std::optional<DataRef> ExtractDataRef(
     const std::optional<A> &x, bool intoSubstring = false) {
   if (x) {
     return ExtractDataRef(*x, intoSubstring);
   } else {
bool IsArrayElement(const Expr<T> &expr, bool intoSubstring = true,
   } else {
     return false;
   }
 }
 
 template <typename A>
 std::optional<NamedEntity> ExtractNamedEntity(const A &x) {
   if (auto dataRef{ExtractDataRef(x, true)}) {
-    return std::visit(
+    return common::visit(
         common::visitors{
             [](SymbolRef &&symbol) -> std::optional<NamedEntity> {
               return NamedEntity{symbol};
             },
             [](Component &&component) -> std::optional<NamedEntity> {
               return NamedEntity{std::move(component)};
             },
             [](CoarrayRef &&co) -> std::optional<NamedEntity> {

 
 struct ExtractCoindexedObjectHelper {
   template <typename A> std::optional<CoarrayRef> operator()(const A &) const {
     return std::nullopt;
   }
   std::optional<CoarrayRef> operator()(const CoarrayRef &x) const { return x; }
   template <typename A>
   std::optional<CoarrayRef> operator()(const Expr<A> &expr) const {
-    return std::visit(*this, expr.u);
+    return common::visit(*this, expr.u);
   }
   std::optional<CoarrayRef> operator()(const DataRef &dataRef) const {
-    return std::visit(*this, dataRef.u);
+    return common::visit(*this, dataRef.u);
   }
   std::optional<CoarrayRef> operator()(const NamedEntity &named) const {
     if (const Component * component{named.UnwrapComponent()}) {
       return (*this)(*component);
     } else {
       return std::nullopt;
     }
   }
if constexpr (FROMCAT == TO::category) {
     }
   } else if constexpr (TO::category == TypeCategory::Complex) {
     using Part = typename TO::Part;
     Scalar<Part> zero;
     return Expr<TO>{ComplexConstructor<TO::kind>{
         ConvertToType<Part>(std::move(x)), Expr<Part>{Constant<Part>{zero}}}};
   } else if constexpr (FROMCAT == TypeCategory::Complex) {
     // Extract and convert the real component of a complex value
-    return std::visit(
+    return common::visit(
         [&](auto &&z) {
           using ZType = ResultType<decltype(z)>;
           using Part = typename ZType::Part;
           return ConvertToType<TO, TypeCategory::Real>(Expr<SomeReal>{
               Expr<Part>{ComplexComponent<Part::kind>{false, std::move(z)}}});
         },
         std::move(x.u));
   } else {

 common::IfNoLvalue<Expr<Type<TC, TK>>, FROM> ConvertTo(
     const Expr<Type<TC, TK>> &, FROM &&x) {
   return ConvertToType<Type<TC, TK>>(std::move(x));
 }
 
 template <TypeCategory TC, typename FROM>
 common::IfNoLvalue<Expr<SomeKind<TC>>, FROM> ConvertTo(
     const Expr<SomeKind<TC>> &to, FROM &&from) {
-  return std::visit(
+  return common::visit(
       [&](const auto &toKindExpr) {
         using KindExpr = std::decay_t<decltype(toKindExpr)>;
         return AsCategoryExpr(
             ConvertToType<ResultType<KindExpr>>(std::move(from)));
       },
       to.u);
 }
 
 template <typename FROM>
 common::IfNoLvalue<Expr<SomeType>, FROM> ConvertTo(
     const Expr<SomeType> &to, FROM &&from) {
-  return std::visit(
+  return common::visit(
       [&](const auto &toCatExpr) {
         return AsGenericExpr(ConvertTo(toCatExpr, std::move(from)));
       },
       to.u);
 }
 
 // Convert an expression of some known category to a dynamically chosen
 // kind of some category (usually but not necessarily distinct).
common::MapTemplate<SameKindExprsHelper<N>::template SameExprs,
         CategoryTypes<CAT>>;
 
 // Given references to two expressions of arbitrary kind in the same type
 // category, convert one to the kind of the other when it has the smaller kind,
 // then return them in a type-safe package.
 template <TypeCategory CAT>
 SameKindExprs<CAT, 2> AsSameKindExprs(
     Expr<SomeKind<CAT>> &&x, Expr<SomeKind<CAT>> &&y) {
-  return std::visit(
+  return common::visit(
       [&](auto &&kx, auto &&ky) -> SameKindExprs<CAT, 2> {
         using XTy = ResultType<decltype(kx)>;
         using YTy = ResultType<decltype(ky)>;
         if constexpr (std::is_same_v<XTy, YTy>) {
           return {SameExprs<XTy>{std::move(kx), std::move(ky)}};
         } else if constexpr (XTy::kind < YTy::kind) {
           return {SameExprs<YTy>{ConvertTo(ky, std::move(kx)), std::move(ky)}};
         } else {

 
 // Given two expressions of arbitrary kind in the same intrinsic type
 // category, convert one of them if necessary to the larger kind of the
 // other, then combine the resulting homogenized operands with a given
 // operation, returning a new expression in the same type category.
 template <template <typename> class OPR, TypeCategory CAT>
 Expr<SomeKind<CAT>> PromoteAndCombine(
     Expr<SomeKind<CAT>> &&x, Expr<SomeKind<CAT>> &&y) {
-  return std::visit(
+  return common::visit(
       [](auto &&xy) {
         using Ty = ResultType<decltype(xy[0])>;
         return AsCategoryExpr(
             Combine<OPR, Ty>(std::move(xy[0]), std::move(xy[1])));
       },
       AsSameKindExprs(std::move(x), std::move(y)));
 }
 

 }
 
 template <TypeCategory C, int K>
 Expr<Type<C, K>> operator/(Expr<Type<C, K>> &&x, Expr<Type<C, K>> &&y) {
   return AsExpr(Combine<Divide, Type<C, K>>(std::move(x), std::move(y)));
 }
 
 template <TypeCategory C> Expr<SomeKind<C>> operator-(Expr<SomeKind<C>> &&x) {
-  return std::visit(
+  return common::visit(
       [](auto &xk) { return Expr<SomeKind<C>>{-std::move(xk)}; }, x.u);
 }
 
 template <TypeCategory CAT>
 Expr<SomeKind<CAT>> operator+(
     Expr<SomeKind<CAT>> &&x, Expr<SomeKind<CAT>> &&y) {
   return PromoteAndCombine<Add, CAT>(std::move(x), std::move(y));
 }
template <typename A> std::optional<BaseObject> GetBaseObject(const A &) {
   return std::nullopt;
 }
 template <typename T>
 std::optional<BaseObject> GetBaseObject(const Designator<T> &x) {
   return x.GetBaseObject();
 }
 template <typename T>
 std::optional<BaseObject> GetBaseObject(const Expr<T> &x) {
-  return std::visit([](const auto &y) { return GetBaseObject(y); }, x.u);
+  return common::visit([](const auto &y) { return GetBaseObject(y); }, x.u);
 }
 template <typename A>
 std::optional<BaseObject> GetBaseObject(const std::optional<A> &x) {
   if (x) {
     return GetBaseObject(*x);
   } else {
     return std::nullopt;
   }
if (lbounds_) {
       expanded.set_lbounds(std::move(*lbounds_));
     }
     return expanded;
   }
   template <typename T> Expr<T> Expand(Parentheses<T> &&x) {
     return Expand(std::move(x.left())); // Constant<> can be parenthesized
   }
   template <typename T> Expr<T> Expand(Expr<T> &&x) {
-    return std::visit([&](auto &&x) { return Expr<T>{Expand(std::move(x))}; },
+    return common::visit(
+        [&](auto &&x) { return Expr<T>{Expand(std::move(x))}; },
         std::move(x.u));
   }
 
 private:
   ConstantSubscripts extents_;
   std::optional<ConstantSubscripts> lbounds_;
 };
 

flang/include/flang/Evaluate/traverse.h

template <typename A> Result operator()(const std::optional<A> &x) const {
     if (x) {
       return visitor_(*x);
     } else {
       return visitor_.Default();
     }
   }
   template <typename... A>
   Result operator()(const std::variant<A...> &u) const {
-    return std::visit(visitor_, u);
+    return common::visit(visitor_, u);
   }
   template <typename A> Result operator()(const std::vector<A> &x) const {
     return CombineContents(x);
   }
 
   // Leaves
   Result operator()(const BOZLiteralConstant &) const {
     return visitor_.Default();

flang/include/flang/Parser/parse-tree-visitor.h

 //===-- include/flang/Parser/parse-tree-visitor.h ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_PARSER_PARSE_TREE_VISITOR_H_
 #define FORTRAN_PARSER_PARSE_TREE_VISITOR_H_
 
 #include "parse-tree.h"
+#include "flang/Common/visit.h"
 #include <cstddef>
 #include <optional>
 #include <tuple>
 #include <utility>
 #include <variant>
 
 /// Parse tree visitor
 /// Call Walk(x, visitor) to visit x and, by default, each node under x.
if (mutator.Pre(x)) {
       ForEachInTuple(x, [&](auto &y) { Walk(y, mutator); });
       mutator.Post(x);
     }
   }
 }
 template <typename V, typename... A>
 void Walk(const std::variant<A...> &x, V &visitor) {
   if (visitor.Pre(x)) {
-    std::visit([&](const auto &y) { Walk(y, visitor); }, x);
+    common::visit([&](const auto &y) { Walk(y, visitor); }, x);
     visitor.Post(x);
   }
 }
 template <typename M, typename... A>
 void Walk(std::variant<A...> &x, M &mutator) {
   if (mutator.Pre(x)) {
-    std::visit([&](auto &y) { Walk(y, mutator); }, x);
+    common::visit([&](auto &y) { Walk(y, mutator); }, x);
     mutator.Post(x);
   }
 }
 template <typename A, typename B, typename V>
 void Walk(const std::pair<A, B> &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.first, visitor);
     Walk(x.second, visitor);

flang/include/flang/Parser/tools.h

struct UnwrapperHelper {
 
   template <typename A, typename B, bool COPY>
   static const A *Unwrap(const common::Indirection<B, COPY> &x) {
     return Unwrap<A>(x.value());
   }
 
   template <typename A, typename... Bs>
   static const A *Unwrap(const std::variant<Bs...> &x) {
-    return std::visit([](const auto &y) { return Unwrap<A>(y); }, x);
+    return common::visit([](const auto &y) { return Unwrap<A>(y); }, x);
   }
 
   template <typename A, typename B>
   static const A *Unwrap(const std::optional<B> &o) {
     if (o) {
       return Unwrap<A>(*o);
     } else {
       return nullptr;

flang/include/flang/Semantics/expression.h

 //===-- include/flang/Semantics/expression.h --------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_SEMANTICS_EXPRESSION_H_
 #define FORTRAN_SEMANTICS_EXPRESSION_H_
 
 #include "semantics.h"
 #include "flang/Common/Fortran.h"
 #include "flang/Common/indirection.h"
 #include "flang/Common/restorer.h"
+#include "flang/Common/visit.h"
 #include "flang/Evaluate/characteristics.h"
 #include "flang/Evaluate/check-expression.h"
 #include "flang/Evaluate/expression.h"
 #include "flang/Evaluate/fold.h"
 #include "flang/Evaluate/tools.h"
 #include "flang/Evaluate/type.h"
 #include "flang/Parser/char-block.h"
 #include "flang/Parser/parse-tree-visitor.h"
private:
   MaybeExpr Analyze(const parser::Expr::OR &);
   MaybeExpr Analyze(const parser::Expr::EQV &);
   MaybeExpr Analyze(const parser::Expr::NEQV &);
   MaybeExpr Analyze(const parser::Expr::DefinedBinary &);
   template <typename A> MaybeExpr Analyze(const A &x) {
     return Analyze(x.u); // default case
   }
   template <typename... As> MaybeExpr Analyze(const std::variant<As...> &u) {
-    return std::visit(
-        [&](const auto &x) {
-          return Analyze(x);
-        },
-        u);
+    return common::visit([&](const auto &x) { return Analyze(x); }, u);
   }
 
   // Analysis subroutines
   int AnalyzeKindParam(
       const std::optional<parser::KindParam> &, int defaultKind);
   template <typename PARSED>
   MaybeExpr ExprOrVariable(const PARSED &, parser::CharBlock source);
   template <typename PARSED> MaybeExpr IntLiteralConstant(const PARSED &);

flang/include/flang/Semantics/symbol.h

 //===-- include/flang/Semantics/symbol.h ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_SEMANTICS_SYMBOL_H_
 #define FORTRAN_SEMANTICS_SYMBOL_H_
 
 #include "type.h"
 #include "flang/Common/Fortran.h"
 #include "flang/Common/enum-set.h"
 #include "flang/Common/reference.h"
+#include "flang/Common/visit.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include <array>
 #include <functional>
 #include <list>
 #include <optional>
 #include <set>
 #include <vector>
 
public:
 
   const std::string *GetBindName() const;
   void SetBindName(std::string &&);
   bool IsFuncResult() const;
   bool IsObjectArray() const;
   bool IsSubprogram() const;
   bool IsFromModFile() const;
   bool HasExplicitInterface() const {
-    return std::visit(common::visitors{
+    return common::visit(common::visitors{
                              [](const SubprogramDetails &) { return true; },
                              [](const SubprogramNameDetails &) { return true; },
                              [&](const ProcEntityDetails &x) {
                                return attrs_.test(Attr::INTRINSIC) ||
                                    x.HasExplicitInterface();
                              },
                              [](const ProcBindingDetails &x) {
                                return x.symbol().HasExplicitInterface();
                              },
                              [](const UseDetails &x) {
                                return x.symbol().HasExplicitInterface();
                              },
                              [](const HostAssocDetails &x) {
                                return x.symbol().HasExplicitInterface();
                              },
                              [](const auto &) { return false; },
                          },
         details_);
   }
 
   bool operator==(const Symbol &that) const { return this == &that; }
   bool operator!=(const Symbol &that) const { return !(*this == that); }
 
   int Rank() const {
-    return std::visit(
+    return common::visit(
         common::visitors{
             [](const SubprogramDetails &sd) {
               return sd.isFunction() ? sd.result().Rank() : 0;
             },
             [](const GenericDetails &) {
               return 0; /*TODO*/
             },
             [](const ProcBindingDetails &x) { return x.symbol().Rank(); },
return common::visit(
               }
             },
             [](const auto &) { return 0; },
         },
         details_);
   }
 
   int Corank() const {
-    return std::visit(
+    return common::visit(
         common::visitors{
             [](const SubprogramDetails &sd) {
               return sd.isFunction() ? sd.result().Corank() : 0;
             },
             [](const GenericDetails &) {
               return 0; /*TODO*/
             },
             [](const UseDetails &x) { return x.symbol().Corank(); },
inline const Symbol &Symbol::GetUltimate() const {
   }
 }
 
 inline DeclTypeSpec *Symbol::GetType() {
   return const_cast<DeclTypeSpec *>(
       const_cast<const Symbol *>(this)->GetType());
 }
 inline const DeclTypeSpec *Symbol::GetType() const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const EntityDetails &x) { return x.type(); },
           [](const ObjectEntityDetails &x) { return x.type(); },
           [](const AssocEntityDetails &x) { return x.type(); },
           [](const SubprogramDetails &x) {
             return x.isFunction() ? x.result().GetType() : nullptr;
           },
           [](const ProcEntityDetails &x) {

flang/include/flang/Semantics/tools.h

 //===-- include/flang/Semantics/tools.h -------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_SEMANTICS_TOOLS_H_
 #define FORTRAN_SEMANTICS_TOOLS_H_
 
 // Simple predicates and look-up functions that are best defined
 // canonically for use in semantic checking.
 
 #include "flang/Common/Fortran.h"
+#include "flang/Common/visit.h"
 #include "flang/Evaluate/expression.h"
 #include "flang/Evaluate/shape.h"
 #include "flang/Evaluate/type.h"
 #include "flang/Evaluate/variable.h"
 #include "flang/Parser/message.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/attr.h"
 #include "flang/Semantics/expression.h"
const Symbol *FindExternallyVisibleObject(
   } else {
     return nullptr;
   }
 }
 
 template <typename T>
 const Symbol *FindExternallyVisibleObject(
     const evaluate::Expr<T> &expr, const Scope &scope) {
-  return std::visit(
+  return common::visit(
       [&](const auto &x) { return FindExternallyVisibleObject(x, scope); },
       expr.u);
 }
 
 // Apply GetUltimate(), then if the symbol is a generic procedure shadowing a
 // specific procedure of the same name, return it instead.
 const Symbol &BypassGeneric(const Symbol &);
 

flang/lib/Evaluate/call.cpp

const Component *ProcedureDesignator::GetComponent() const {
   if (auto *c{std::get_if<common::CopyableIndirection<Component>>(&u)}) {
     return &c->value();
   } else {
     return nullptr;
   }
 }
 
 const Symbol *ProcedureDesignator::GetSymbol() const {
-  return std::visit(common::visitors{
-                        [](SymbolRef symbol) { return &*symbol; },
-                        [](const common::CopyableIndirection<Component> &c) {
-                          return &c.value().GetLastSymbol();
-                        },
-                        [](const auto &) -> const Symbol * { return nullptr; },
-                    },
+  return common::visit(
+      common::visitors{
       u);
 }
 
 std::string ProcedureDesignator::GetName() const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const SpecificIntrinsic &i) { return i.name; },
           [](const Symbol &symbol) { return symbol.name().ToString(); },
           [](const common::CopyableIndirection<Component> &c) {
             return c.value().GetLastSymbol().name().ToString();
           },
       },
       u);

flang/lib/Evaluate/characteristics.cpp

TypeAndShape &TypeAndShape::Rewrite(FoldingContext &context) {
   LEN_ = Fold(context, std::move(LEN_));
   shape_ = Fold(context, std::move(shape_));
   return *this;
 }
 
 std::optional<TypeAndShape> TypeAndShape::Characterize(
     const semantics::Symbol &symbol, FoldingContext &context) {
   const auto &ultimate{symbol.GetUltimate()};
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const semantics::ProcEntityDetails &proc) {
             const semantics::ProcInterface &interface{proc.interface()};
             if (interface.type()) {
               return Characterize(*interface.type(), context);
             } else if (interface.symbol()) {
               return Characterize(*interface.symbol(), context);
             } else {
CopyAttrs<Procedure, Procedure::Attr>(symbol, result,
           {semantics::Attr::ELEMENTAL, Procedure::Attr::Elemental},
           {semantics::Attr::BIND_C, Procedure::Attr::BindC},
       });
   if (IsPureProcedure(symbol) || // works for ENTRY too
       (!symbol.attrs().test(semantics::Attr::IMPURE) &&
           result.attrs.test(Procedure::Attr::Elemental))) {
     result.attrs.set(Procedure::Attr::Pure);
   }
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const semantics::SubprogramDetails &subp)
               -> std::optional<Procedure> {
             if (subp.isFunction()) {
               if (auto fr{
                       FunctionResult::Characterize(subp.result(), context)}) {
                 result.functionResult = std::move(fr);
               } else {
if (auto obj{DummyDataObject::Characterize(symbol, context)}) {
                  CharacterizeDummyProcedure(symbol, context, seenProcs)}) {
     return DummyArgument{std::move(name), std::move(proc.value())};
   }
   return std::nullopt;
 }
 
 std::optional<DummyArgument> DummyArgument::FromActual(
     std::string &&name, const Expr<SomeType> &expr, FoldingContext &context) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const BOZLiteralConstant &) {
             return std::make_optional<DummyArgument>(std::move(name),
                 DummyDataObject{
                     TypeAndShape{DynamicType::TypelessIntrinsicArgument()}});
           },
           [&](const NullPointer &) {
             return std::make_optional<DummyArgument>(std::move(name),
return common::visit(
               return std::optional<DummyArgument>{};
             }
           },
       },
       expr.u);
 }
 
 bool DummyArgument::IsOptional() const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const DummyDataObject &data) {
             return data.attrs.test(DummyDataObject::Attr::Optional);
           },
           [](const DummyProcedure &proc) {
             return proc.attrs.test(DummyProcedure::Attr::Optional);
           },
           [](const AlternateReturn &) { return false; },
       },
       u);
 }
 
 void DummyArgument::SetOptional(bool value) {
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [value](DummyDataObject &data) {
                       data.attrs.set(DummyDataObject::Attr::Optional, value);
                     },
                     [value](DummyProcedure &proc) {
                       proc.attrs.set(DummyProcedure::Attr::Optional, value);
                     },
                     [](AlternateReturn &) { DIE("cannot set optional"); },
                 },
       u);
 }
 
 void DummyArgument::SetIntent(common::Intent intent) {
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [intent](DummyDataObject &data) { data.intent = intent; },
                     [intent](DummyProcedure &proc) { proc.intent = intent; },
                     [](AlternateReturn &) { DIE("cannot set intent"); },
                 },
       u);
 }
 
 common::Intent DummyArgument::GetIntent() const {
-  return std::visit(common::visitors{
-                        [](const DummyDataObject &data) { return data.intent; },
-                        [](const DummyProcedure &proc) { return proc.intent; },
-                        [](const AlternateReturn &) -> common::Intent {
-                          DIE("Alternate returns have no intent");
-                        },
-                    },
+  return common::visit(
+      common::visitors{
       u);
 }
 
 bool DummyArgument::CanBePassedViaImplicitInterface() const {
   if (const auto *object{std::get_if<DummyDataObject>(&u)}) {
     return object->CanBePassedViaImplicitInterface();
   } else {
     return true;
   }
 }
 
 bool DummyArgument::IsTypelessIntrinsicDummy() const {
   const auto *argObj{std::get_if<characteristics::DummyDataObject>(&u)};
   return argObj && argObj->type.type().IsTypelessIntrinsicArgument();
 }
 
 llvm::raw_ostream &DummyArgument::Dump(llvm::raw_ostream &o) const {
   if (!name.empty()) {
     o << name << '=';
   }
   if (pass) {
     o << " PASS";
   }
-  std::visit([&](const auto &x) { x.Dump(o); }, u);
+  common::visit([&](const auto &x) { x.Dump(o); }, u);
   return o;
 }
 
 FunctionResult::FunctionResult(DynamicType t) : u{TypeAndShape{t}} {}
 FunctionResult::FunctionResult(TypeAndShape &&t) : u{std::move(t)} {}
 FunctionResult::FunctionResult(Procedure &&p) : u{std::move(p)} {}
 FunctionResult::~FunctionResult() {}
 
if (attrs != actualAttrs) {
     } else {
       return false;
     }
   }
 }
 
 llvm::raw_ostream &FunctionResult::Dump(llvm::raw_ostream &o) const {
   attrs.Dump(o, EnumToString);
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [&](const TypeAndShape &ts) { ts.Dump(o); },
                     [&](const CopyableIndirection<Procedure> &p) {
                       p.value().Dump(o << " procedure(") << ')';
                     },
                 },
       u);
   return o;
 }
 
 Procedure::Procedure(FunctionResult &&fr, DummyArguments &&args, Attrs a)
     : functionResult{std::move(fr)}, dummyArguments{std::move(args)}, attrs{a} {
 }
 Procedure::Procedure(DummyArguments &&args, Attrs a)
int DistinguishUtils::CountNotDistinguishableFrom(
   });
 }
 
 bool DistinguishUtils::Distinguishable(
     const DummyArgument &x, const DummyArgument &y) const {
   if (x.u.index() != y.u.index()) {
     return true; // different kind: data/proc/alt-return
   }
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const DummyDataObject &z) {
             return Distinguishable(z, std::get<DummyDataObject>(y.u));
           },
           [&](const DummyProcedure &z) {
             return Distinguishable(z, std::get<DummyProcedure>(y.u));
           },
           [&](const AlternateReturn &) { return false; },
bool DistinguishUtils::Distinguishable(
   }
 }
 
 bool DistinguishUtils::Distinguishable(
     const FunctionResult &x, const FunctionResult &y) const {
   if (x.u.index() != y.u.index()) {
     return true; // one is data object, one is procedure
   }
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const TypeAndShape &z) {
             return Distinguishable(z, std::get<TypeAndShape>(y.u));
           },
           [&](const CopyableIndirection<Procedure> &z) {
             return Distinguishable(z.value(),
                 std::get<CopyableIndirection<Procedure>>(y.u).value());
           },

flang/lib/Evaluate/check-expression.cpp

 // IsActuallyConstant()
 struct IsActuallyConstantHelper {
   template <typename A> bool operator()(const A &) { return false; }
   template <typename T> bool operator()(const Constant<T> &) { return true; }
   template <typename T> bool operator()(const Parentheses<T> &x) {
     return (*this)(x.left());
   }
   template <typename T> bool operator()(const Expr<T> &x) {
-    return std::visit([=](const auto &y) { return (*this)(y); }, x.u);
+    return common::visit([this](const auto &y) { return (*this)(y); }, x.u);
   }
   bool operator()(const Expr<SomeType> &x) {
     if (IsNullPointer(x)) {
       return true;
     }
-    return std::visit([this](const auto &y) { return (*this)(y); }, x.u);
+    return common::visit([this](const auto &y) { return (*this)(y); }, x.u);
   }
   template <typename A> bool operator()(const A *x) { return x && (*this)(*x); }
   template <typename A> bool operator()(const std::optional<A> &x) {
     return x && (*this)(*x);
   }
 };
 
 template <typename A> bool IsActuallyConstant(const A &x) {
public:
   }
   bool operator()(const StaticDataObject &) const { return false; }
   bool operator()(const TypeParamInquiry &) const { return false; }
   bool operator()(const Triplet &x) const {
     return IsConstantExpr(x.lower()) && IsConstantExpr(x.upper()) &&
         IsConstantExpr(x.stride());
   }
   bool operator()(const Subscript &x) const {
-    return std::visit(common::visitors{
+    return common::visit(common::visitors{
                              [&](const Triplet &t) { return (*this)(t); },
                              [&](const auto &y) {
                                return y.value().Rank() == 0 &&
                                    IsConstantExpr(y.value());
                              },
                          },
         x.u);
   }
   bool operator()(const CoarrayRef &) const { return false; }
   bool operator()(const Component &x) {
     return CheckVarOrComponent(x.GetLastSymbol()) && (*this)(x.base());
   }
   bool operator()(const Substring &x) const {
     return IsConstantExpr(x.lower()) && IsConstantExpr(x.upper()) &&
if (!result && messages && !helper.emittedMessage()) {
     messages->Say(
         "An initial data target must be a designator with constant subscripts"_err_en_US);
   }
   return result;
 }
 
 bool IsInitialProcedureTarget(const semantics::Symbol &symbol) {
   const auto &ultimate{symbol.GetUltimate()};
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const semantics::SubprogramDetails &subp) {
             return !subp.isDummy();
           },
           [](const semantics::SubprogramNameDetails &) { return true; },
           [&](const semantics::ProcEntityDetails &proc) {
             return !semantics::IsPointer(ultimate) && !proc.isDummy();
           },
template <typename T> Constant<T> ChangeLbounds(Constant<T> &&x) {
     x.set_lbounds(std::move(lbounds_));
     return std::move(x);
   }
   template <typename T> Expr<T> ChangeLbounds(Parentheses<T> &&x) {
     return ChangeLbounds(
         std::move(x.left())); // Constant<> can be parenthesized
   }
   template <typename T> Expr<T> ChangeLbounds(Expr<T> &&x) {
-    return std::visit(
+    return common::visit(
         [&](auto &&x) { return Expr<T>{ChangeLbounds(std::move(x))}; },
         std::move(x.u)); // recurse until we hit a constant
   }
 
 private:
   ConstantSubscripts &&lbounds_;
 };
 

flang/lib/Evaluate/expression.cpp

 using namespace Fortran::parser::literals;
 
 namespace Fortran::evaluate {
 
 template <int KIND>
 std::optional<Expr<SubscriptInteger>>
 Expr<Type<TypeCategory::Character, KIND>>::LEN() const {
   using T = std::optional<Expr<SubscriptInteger>>;
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const Constant<Result> &c) -> T {
             return AsExpr(Constant<SubscriptInteger>{c.LEN()});
           },
           [](const ArrayConstructor<Result> &a) -> T { return a.LEN(); },
           [](const Parentheses<Result> &x) { return x.left().LEN(); },
           [](const Convert<Result> &x) {
-            return std::visit(
+            return common::visit(
                 [&](const auto &kx) { return kx.LEN(); }, x.left().u);
           },
           [](const Concat<KIND> &c) -> T {
             if (auto llen{c.left().LEN()}) {
               if (auto rlen{c.right().LEN()}) {
                 return *std::move(llen) + *std::move(rlen);
               }
             }

 }
 #endif
 
 template <typename A>
 std::optional<DynamicType> ExpressionBase<A>::GetType() const {
   if constexpr (IsLengthlessIntrinsicType<Result>) {
     return Result::GetType();
   } else {
-    return std::visit(
+    return common::visit(
         [&](const auto &x) -> std::optional<DynamicType> {
           if constexpr (!common::HasMember<decltype(x), TypelessExpression>) {
             return x.GetType();
           }
           return std::nullopt; // w/o "else" to dodge bogus g++ 8.1 warning
         },
         derived().u);
   }
 }
 
 template <typename A> int ExpressionBase<A>::Rank() const {
-  return std::visit(
+  return common::visit(
       [](const auto &x) {
         if constexpr (common::HasMember<decltype(x), TypelessExpression>) {
           return 0;
         } else {
           return x.Rank();
         }
       },
       derived().u);

 
 GenericAssignmentWrapper::~GenericAssignmentWrapper() {}
 
 void GenericAssignmentWrapper::Deleter(GenericAssignmentWrapper *p) {
   delete p;
 }
 
 template <TypeCategory CAT> int Expr<SomeKind<CAT>>::GetKind() const {
-  return std::visit(
+  return common::visit(
       [](const auto &kx) { return std::decay_t<decltype(kx)>::Result::kind; },
       u);
 }
 
 int Expr<SomeCharacter>::GetKind() const {
-  return std::visit(
+  return common::visit(
       [](const auto &kx) { return std::decay_t<decltype(kx)>::Result::kind; },
       u);
 }
 
 std::optional<Expr<SubscriptInteger>> Expr<SomeCharacter>::LEN() const {
-  return std::visit([](const auto &kx) { return kx.LEN(); }, u);
+  return common::visit([](const auto &kx) { return kx.LEN(); }, u);
 }
 
 #ifdef _MSC_VER // disable bogus warning about missing definitions
 #pragma warning(disable : 4661)
 #endif
 INSTANTIATE_EXPRESSION_TEMPLATES
 } // namespace Fortran::evaluate

flang/lib/Evaluate/fold-designator.cpp

if (auto extents{GetConstantExtents(context_, array)}) {
             return std::nullopt;
           }
           auto stride{*bytes};
           int dim{0};
           for (const Subscript &subscript : x.subscript()) {
             ConstantSubscript lower{lowerBounds->at(dim)};
             ConstantSubscript extent{extents->at(dim)};
             ConstantSubscript upper{lower + extent - 1};
-            if (!std::visit(
+            if (!common::visit(
                     common::visitors{
                         [&](const IndirectSubscriptIntegerExpr &expr) {
                           auto folded{
                               Fold(context_, common::Clone(expr.value()))};
                           if (auto value{UnwrapConstantValue<SubscriptInteger>(
                                   folded)}) {
                             CHECK(value->Rank() <= 1);
                             if (value->size() != 0) {
if (auto result{FoldDesignator(z.complex(), which)}) {
     return result;
   } else {
     return std::nullopt;
   }
 }
 
 std::optional<OffsetSymbol> DesignatorFolder::FoldDesignator(
     const DataRef &dataRef, ConstantSubscript which) {
-  return std::visit(
+  return common::visit(
       [&](const auto &x) { return FoldDesignator(x, which); }, dataRef.u);
 }
 
 std::optional<OffsetSymbol> DesignatorFolder::FoldDesignator(
     const NamedEntity &entity, ConstantSubscript which) {
   return entity.IsSymbol() ? FoldDesignator(entity.GetLastSymbol(), which)
                            : FoldDesignator(entity.GetComponent(), which);
 }
if (std::optional<Expr<SomeType>> result{
                 ToInt64(type->MeasureSizeInBytes(context, true))}) {
           if (auto *zExpr{std::get_if<Expr<SomeComplex>>(&result->u)}) {
             if (size * 2 > static_cast<std::size_t>(*elementBytes)) {
               return result;
             } else if (offset == 0 || offset * 2 == *elementBytes) {
               // Pick a COMPLEX component
               auto part{
                   offset == 0 ? ComplexPart::Part::RE : ComplexPart::Part::IM};
-              return std::visit(
+              return common::visit(
                   [&](const auto &z) -> std::optional<Expr<SomeType>> {
                     using PartType = typename ResultType<decltype(z)>::Part;
                     return AsGenericExpr(Designator<PartType>{ComplexPart{
                         ExtractDataRef(std::move(*zExpr)).value(), part}});
                   },
                   zExpr->u);
             }
           } else if (auto *cExpr{
                          std::get_if<Expr<SomeCharacter>>(&result->u)}) {
             if (offset > 0 || size != static_cast<std::size_t>(*elementBytes)) {
               // Select a substring
-              return std::visit(
+              return common::visit(
                   [&](const auto &x) -> std::optional<Expr<SomeType>> {
                     using T = typename std::decay_t<decltype(x)>::Result;
                     return AsGenericExpr(Designator<T>{
                         Substring{ExtractDataRef(std::move(*cExpr)).value(),
                             std::optional<Expr<SubscriptInteger>>{
                                 1 + (offset / T::kind)},
                             std::optional<Expr<SubscriptInteger>>{
                                 1 + ((offset + size - 1) / T::kind)}}});

flang/lib/Evaluate/fold-implementation.h

if (auto scalar{structures.GetScalarValue()}) {
     }
   }
   return std::nullopt;
 }
 
 template <typename T>
 std::optional<Constant<T>> Folder<T>::GetConstantComponent(Component &component,
     const std::vector<Constant<SubscriptInteger>> *subscripts) {
-  if (std::optional<Constant<SomeDerived>> structures{std::visit(
+  if (std::optional<Constant<SomeDerived>> structures{common::visit(
           common::visitors{
               [&](const Symbol &symbol) {
                 return Folder<SomeDerived>{context_}.GetNamedConstant(symbol);
               },
               [&](ArrayRef &aRef) {
                 return Folder<SomeDerived>{context_}.Folding(aRef);
               },
               [&](Component &base) {
if (auto *substring{common::Unwrap<Substring>(designator.u)}) {
       }
       if (auto length{ToInt64(Fold(context_, substring->LEN()))}) {
         if (*length == 0) {
           return Expr<T>{Constant<T>{Scalar<T>{}}};
         }
       }
     }
   }
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](SymbolRef &&symbol) {
             if (auto constant{GetNamedConstant(*symbol)}) {
               return Expr<T>{std::move(*constant)};
             }
             return Expr<T>{std::move(designator)};
           },
           [&](ArrayRef &&aRef) {

 std::optional<std::int64_t> GetInt64Arg(const std::optional<ActualArgument> &);
 std::optional<std::int64_t> GetInt64ArgOr(
     const std::optional<ActualArgument> &, std::int64_t defaultValue);
 
 template <typename A, typename B>
 std::optional<std::vector<A>> GetIntegerVector(const B &x) {
   static_assert(std::is_integral_v<A>);
   if (const auto *someInteger{UnwrapExpr<Expr<SomeInteger>>(x)}) {
-    return std::visit(
+    return common::visit(
         [](const auto &typedExpr) -> std::optional<std::vector<A>> {
           using T = ResultType<decltype(typedExpr)>;
           if (const auto *constant{UnwrapConstantValue<T>(typedExpr)}) {
             if (constant->Rank() == 1) {
               std::vector<A> result;
               for (const auto &value : constant->values()) {
                 result.push_back(static_cast<A>(value.ToInt64()));
               }
intrinsic.name =
       intrinsic.name.find("max") != std::string::npos ? "max"s : "min"s;
   intrinsic.characteristics.value().functionResult.value().SetType(resultType);
   auto insertConversion{[&](const auto &x) -> Expr<T> {
     using TR = ResultType<decltype(x)>;
     FunctionRef<TR> maxRef{std::move(funcRef.proc()), std::move(args)};
     return Fold(context, ConvertToType<T>(AsCategoryExpr(std::move(maxRef))));
   }};
   if (auto *sx{UnwrapExpr<Expr<SomeReal>>(*resultTypeArg)}) {
-    return std::visit(insertConversion, sx->u);
+    return common::visit(insertConversion, sx->u);
   }
   auto &sx{DEREF(UnwrapExpr<Expr<SomeInteger>>(*resultTypeArg))};
-  return std::visit(insertConversion, sx.u);
+  return common::visit(insertConversion, sx.u);
 }
 
 template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, FunctionRef<T> &&funcRef) {
   ActualArguments &args{funcRef.arguments()};
   for (std::optional<ActualArgument> &arg : args) {
     if (auto *expr{UnwrapExpr<Expr<SomeType>>(arg)}) {
       *expr = Fold(context, std::move(*expr));
if (start && end && step && *step != 0) {
       }
       context_.EndImpliedDo(iDo.name());
       return result;
     } else {
       return false;
     }
   }
   bool FoldArray(const ArrayConstructorValue<T> &x) {
-    return std::visit([&](const auto &y) { return FoldArray(y); }, x.u);
+    return common::visit([&](const auto &y) { return FoldArray(y); }, x.u);
   }
   bool FoldArray(const ArrayConstructorValues<T> &xs) {
     for (const auto &x : xs) {
       if (!FoldArray(x)) {
         return false;
       }
     }
     return true;
std::optional<Expr<T>> AsFlatArrayConstructor(const Expr<T> &expr) {
   }
   return std::nullopt;
 }
 
 template <TypeCategory CAT>
 std::enable_if_t<CAT != TypeCategory::Derived,
     std::optional<Expr<SomeKind<CAT>>>>
 AsFlatArrayConstructor(const Expr<SomeKind<CAT>> &expr) {
-  return std::visit(
+  return common::visit(
       [&](const auto &kindExpr) -> std::optional<Expr<SomeKind<CAT>>> {
         if (auto flattened{AsFlatArrayConstructor(kindExpr)}) {
           return Expr<SomeKind<CAT>>{std::move(*flattened)};
         } else {
           return std::nullopt;
         }
       },
       expr.u);

 
 // Unary case
 template <typename RESULT, typename OPERAND>
 Expr<RESULT> MapOperation(FoldingContext &context,
     std::function<Expr<RESULT>(Expr<OPERAND> &&)> &&f, const Shape &shape,
     Expr<OPERAND> &&values) {
   ArrayConstructor<RESULT> result{values};
   if constexpr (common::HasMember<OPERAND, AllIntrinsicCategoryTypes>) {
-    std::visit(
+    common::visit(
         [&](auto &&kindExpr) {
           using kindType = ResultType<decltype(kindExpr)>;
           auto &aConst{std::get<ArrayConstructor<kindType>>(kindExpr.u)};
           for (auto &acValue : aConst) {
             auto &scalar{std::get<Expr<kindType>>(acValue.u)};
             result.Push(Fold(context, f(Expr<OPERAND>{std::move(scalar)})));
           }
         },

 template <typename RESULT, typename LEFT, typename RIGHT>
 Expr<RESULT> MapOperation(FoldingContext &context,
     std::function<Expr<RESULT>(Expr<LEFT> &&, Expr<RIGHT> &&)> &&f,
     const Shape &shape, std::optional<Expr<SubscriptInteger>> &&length,
     Expr<LEFT> &&leftValues, Expr<RIGHT> &&rightValues) {
   auto result{ArrayConstructorFromMold<RESULT>(leftValues, std::move(length))};
   auto &leftArrConst{std::get<ArrayConstructor<LEFT>>(leftValues.u)};
   if constexpr (common::HasMember<RIGHT, AllIntrinsicCategoryTypes>) {
-    std::visit(
+    common::visit(
         [&](auto &&kindExpr) {
           using kindType = ResultType<decltype(kindExpr)>;
 
           auto &rightArrConst{std::get<ArrayConstructor<kindType>>(kindExpr.u)};
           auto rightIter{rightArrConst.begin()};
           for (auto &leftValue : leftArrConst) {
             CHECK(rightIter != rightArrConst.end());
             auto &leftScalar{std::get<Expr<LEFT>>(leftValue.u)};

 // scalar * array case
 template <typename RESULT, typename LEFT, typename RIGHT>
 Expr<RESULT> MapOperation(FoldingContext &context,
     std::function<Expr<RESULT>(Expr<LEFT> &&, Expr<RIGHT> &&)> &&f,
     const Shape &shape, std::optional<Expr<SubscriptInteger>> &&length,
     const Expr<LEFT> &leftScalar, Expr<RIGHT> &&rightValues) {
   auto result{ArrayConstructorFromMold<RESULT>(leftScalar, std::move(length))};
   if constexpr (common::HasMember<RIGHT, AllIntrinsicCategoryTypes>) {
-    std::visit(
+    common::visit(
         [&](auto &&kindExpr) {
           using kindType = ResultType<decltype(kindExpr)>;
           auto &rightArrConst{std::get<ArrayConstructor<kindType>>(kindExpr.u)};
           for (auto &rightValue : rightArrConst) {
             auto &rightScalar{std::get<Expr<kindType>>(rightValue.u)};
             result.Push(Fold(context,
                 f(Expr<LEFT>{leftScalar},
                     Expr<RIGHT>{std::move(rightScalar)})));
Expr<TO> FoldOperation(
     FoldingContext &context, Convert<TO, FROMCAT> &&convert) {
   if (auto array{ApplyElementwise(context, convert)}) {
     return *array;
   }
   struct {
     FoldingContext &context;
     Convert<TO, FROMCAT> &convert;
   } msvcWorkaround{context, convert};
-  return std::visit(
+  return common::visit(
       [&msvcWorkaround](auto &kindExpr) -> Expr<TO> {
         using Operand = ResultType<decltype(kindExpr)>;
         // This variable is a workaround for msvc which emits an error when
         // using the FROMCAT template parameter below.
         TypeCategory constexpr FromCat{FROMCAT};
         static_assert(FromCat == Operand::category);
         auto &convert{msvcWorkaround.convert};
         char buffer[64];
Expr<T> FoldOperation(FoldingContext &context, Power<T> &&x) {
   return Expr<T>{std::move(x)};
 }
 
 template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, RealToIntPower<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
   }
-  return std::visit(
+  return common::visit(
       [&](auto &y) -> Expr<T> {
         if (auto folded{OperandsAreConstants(x.left(), y)}) {
           auto power{evaluate::IntPower(folded->first, folded->second)};
           RealFlagWarnings(context, power.flags, "power with INTEGER exponent");
           if (context.flushSubnormalsToZero()) {
             power.value = power.value.FlushSubnormalToZero();
           }
           return Expr<T>{Constant<T>{power.value}};
Expr<T> FoldOperation(FoldingContext &context, Extremum<T> &&x) {
   return Expr<T>{std::move(x)};
 }
 
 template <int KIND>
 Expr<Type<TypeCategory::Real, KIND>> ToReal(
     FoldingContext &context, Expr<SomeType> &&expr) {
   using Result = Type<TypeCategory::Real, KIND>;
   std::optional<Expr<Result>> result;
-  std::visit(
+  common::visit(
       [&](auto &&x) {
         using From = std::decay_t<decltype(x)>;
         if constexpr (std::is_same_v<From, BOZLiteralConstant>) {
           // Move the bits without any integer->real conversion
           From original{x};
           result = ConvertToType<Result>(std::move(x));
           const auto *constant{UnwrapExpr<Constant<Result>>(*result)};
           CHECK(constant);
common::visit(
         }
       },
       std::move(expr.u));
   return result.value();
 }
 
 template <typename T>
 Expr<T> ExpressionBase<T>::Rewrite(FoldingContext &context, Expr<T> &&expr) {
-  return std::visit(
+  return common::visit(
       [&](auto &&x) -> Expr<T> {
         if constexpr (IsSpecificIntrinsicType<T>) {
           return FoldOperation(context, std::move(x));
         } else if constexpr (std::is_same_v<T, SomeDerived>) {
           return FoldOperation(context, std::move(x));
         } else if constexpr (common::HasMember<decltype(x),
                                  TypelessExpression>) {
           return std::move(expr);

flang/lib/Evaluate/fold-integer.cpp

public:
 
   template <typename T> ConstantSubscript GetLbound(const Parentheses<T> &x) {
     // Strip off the parentheses
     return GetLbound(x.left());
   }
 
   template <typename T> ConstantSubscript GetLbound(const Expr<T> &x) {
     // recurse through Expr<T>'a until we hit a constant
-    return std::visit([&](const auto &inner) { return GetLbound(inner); },
+    return common::visit([&](const auto &inner) { return GetLbound(inner); },
         //      [&](const auto &) { return 0; },
         x.u);
   }
 
 private:
   ConstantSubscript dim_;
 };
 
Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
   } else if (name == "bit_size") {
     return Expr<T>{Scalar<T>::bits};
   } else if (name == "ceiling" || name == "floor" || name == "nint") {
     if (const auto *cx{UnwrapExpr<Expr<SomeReal>>(args[0])}) {
       // NINT rounds ties away from zero, not to even
       common::RoundingMode mode{name == "ceiling" ? common::RoundingMode::Up
               : name == "floor"                   ? common::RoundingMode::Down
                                 : common::RoundingMode::TiesAwayFromZero};
-      return std::visit(
+      return common::visit(
           [&](const auto &kx) {
             using TR = ResultType<decltype(kx)>;
             return FoldElementalIntrinsic<T, TR>(context, std::move(funcRef),
                 ScalarFunc<T, TR>([&](const Scalar<TR> &x) {
                   auto y{x.template ToInteger<Scalar<T>>(mode)};
                   if (y.flags.test(RealFlag::Overflow)) {
                     context.messages().Say(
                         "%s intrinsic folding overflow"_warn_en_US, name);
                   }
                   return y.value;
                 }));
           },
           cx->u);
     }
   } else if (name == "count") {
     return FoldCount<T>(context, std::move(funcRef));
   } else if (name == "digits") {
     if (const auto *cx{UnwrapExpr<Expr<SomeInteger>>(args[0])}) {
-      return Expr<T>{std::visit(
+      return Expr<T>{common::visit(
           [](const auto &kx) {
             return Scalar<ResultType<decltype(kx)>>::DIGITS;
           },
           cx->u)};
     } else if (const auto *cx{UnwrapExpr<Expr<SomeReal>>(args[0])}) {
-      return Expr<T>{std::visit(
+      return Expr<T>{common::visit(
           [](const auto &kx) {
             return Scalar<ResultType<decltype(kx)>>::DIGITS;
           },
           cx->u)};
     } else if (const auto *cx{UnwrapExpr<Expr<SomeComplex>>(args[0])}) {
-      return Expr<T>{std::visit(
+      return Expr<T>{common::visit(
           [](const auto &kx) {
             return Scalar<typename ResultType<decltype(kx)>::Part>::DIGITS;
           },
           cx->u)};
     }
   } else if (name == "dim") {
     return FoldElementalIntrinsic<T, T, T>(
         context, std::move(funcRef), &Scalar<T>::DIM);
   } else if (name == "dshiftl" || name == "dshiftr") {
     const auto fptr{
         name == "dshiftl" ? &Scalar<T>::DSHIFTL : &Scalar<T>::DSHIFTR};
     // Third argument can be of any kind. However, it must be smaller or equal
     // than BIT_SIZE. It can be converted to Int4 to simplify.
     return FoldElementalIntrinsic<T, T, T, Int4>(context, std::move(funcRef),
         ScalarFunc<T, T, T, Int4>(
             [&fptr](const Scalar<T> &i, const Scalar<T> &j,
                 const Scalar<Int4> &shift) -> Scalar<T> {
               return std::invoke(fptr, i, j, static_cast<int>(shift.ToInt64()));
             }));
   } else if (name == "exponent") {
     if (auto *sx{UnwrapExpr<Expr<SomeReal>>(args[0])}) {
-      return std::visit(
+      return common::visit(
           [&funcRef, &context](const auto &x) -> Expr<T> {
             using TR = typename std::decay_t<decltype(x)>::Result;
             return FoldElementalIntrinsic<T, TR>(context, std::move(funcRef),
                 &Scalar<TR>::template EXPONENT<Scalar<T>>);
           },
           sx->u);
     } else {
       DIE("exponent argument must be real");
     }
   } else if (name == "findloc") {
     return FoldLocation<WhichLocation::Findloc, T>(context, std::move(funcRef));
   } else if (name == "huge") {
     return Expr<T>{Scalar<T>::HUGE()};
   } else if (name == "iachar" || name == "ichar") {
     auto *someChar{UnwrapExpr<Expr<SomeCharacter>>(args[0])};
     CHECK(someChar);
     if (auto len{ToInt64(someChar->LEN())}) {
       if (len.value() != 1) {
         // Do not die, this was not checked before
         context.messages().Say(
             "Character in intrinsic function %s must have length one"_warn_en_US,
             name);
       } else {
-        return std::visit(
+        return common::visit(
             [&funcRef, &context](const auto &str) -> Expr<T> {
               using Char = typename std::decay_t<decltype(str)>::Result;
               return FoldElementalIntrinsic<T, Char>(context,
                   std::move(funcRef),
                   ScalarFunc<T, Char>([](const Scalar<Char> &c) {
                     return Scalar<T>{CharacterUtils<Char::kind>::ICHAR(c)};
                   }));
             },
return FoldElementalIntrinsic<T, T, Int4>(context, std::move(funcRef),
             context.messages().Say(
                 "bit position for %s (%d) is not less than %d"_err_en_US, name,
                 posVal, i.bits);
           }
           return std::invoke(fptr, i, posVal);
         }));
   } else if (name == "index" || name == "scan" || name == "verify") {
     if (auto *charExpr{UnwrapExpr<Expr<SomeCharacter>>(args[0])}) {
-      return std::visit(
+      return common::visit(
           [&](const auto &kch) -> Expr<T> {
             using TC = typename std::decay_t<decltype(kch)>::Result;
             if (UnwrapExpr<Expr<SomeLogical>>(args[2])) { // BACK=
               return FoldElementalIntrinsic<T, TC, TC, LogicalResult>(context,
                   std::move(funcRef),
                   ScalarFunc<T, TC, TC, LogicalResult>{
                       [&name](const Scalar<TC> &str, const Scalar<TC> &other,
                           const Scalar<LogicalResult> &back) -> Scalar<T> {
if (auto *charExpr{UnwrapExpr<Expr<SomeCharacter>>(args[0])}) {
             }
           },
           charExpr->u);
     } else {
       DIE("first argument must be CHARACTER");
     }
   } else if (name == "int") {
     if (auto *expr{UnwrapExpr<Expr<SomeType>>(args[0])}) {
-      return std::visit(
+      return common::visit(
           [&](auto &&x) -> Expr<T> {
             using From = std::decay_t<decltype(x)>;
             if constexpr (std::is_same_v<From, BOZLiteralConstant> ||
                 IsNumericCategoryExpr<From>()) {
               return Fold(context, ConvertToType<T>(std::move(x)));
             }
             DIE("int() argument type not valid");
           },
return FoldElementalIntrinsic<T, T, Int4>(context, std::move(funcRef),
           }
           return i.ISHFT(posVal);
         }));
   } else if (name == "lbound") {
     return LBOUND(context, std::move(funcRef));
   } else if (name == "leadz" || name == "trailz" || name == "poppar" ||
       name == "popcnt") {
     if (auto *sn{UnwrapExpr<Expr<SomeInteger>>(args[0])}) {
-      return std::visit(
+      return common::visit(
           [&funcRef, &context, &name](const auto &n) -> Expr<T> {
             using TI = typename std::decay_t<decltype(n)>::Result;
             if (name == "poppar") {
               return FoldElementalIntrinsic<T, TI>(context, std::move(funcRef),
                   ScalarFunc<T, TI>([](const Scalar<TI> &i) -> Scalar<T> {
                     return Scalar<T>{i.POPPAR() ? 1 : 0};
                   }));
             }
if (auto *sn{UnwrapExpr<Expr<SomeInteger>>(args[0])}) {
                 }));
           },
           sn->u);
     } else {
       DIE("leadz argument must be integer");
     }
   } else if (name == "len") {
     if (auto *charExpr{UnwrapExpr<Expr<SomeCharacter>>(args[0])}) {
-      return std::visit(
+      return common::visit(
           [&](auto &kx) {
             if (auto len{kx.LEN()}) {
               if (IsScopeInvariantExpr(*len)) {
                 return Fold(context, ConvertToType<T>(*std::move(len)));
               } else {
                 return Expr<T>{std::move(funcRef)};
               }
             } else {
               return Expr<T>{std::move(funcRef)};
             }
           },
           charExpr->u);
     } else {
       DIE("len() argument must be of character type");
     }
   } else if (name == "len_trim") {
     if (auto *charExpr{UnwrapExpr<Expr<SomeCharacter>>(args[0])}) {
-      return std::visit(
+      return common::visit(
           [&](const auto &kch) -> Expr<T> {
             using TC = typename std::decay_t<decltype(kch)>::Result;
             return FoldElementalIntrinsic<T, TC>(context, std::move(funcRef),
                 ScalarFunc<T, TC>{[](const Scalar<TC> &str) -> Scalar<T> {
                   return CharacterUtils<TC::kind>::LEN_TRIM(str);
                 }});
           },
           charExpr->u);
return FoldElementalIntrinsic<T, Int4>(context, std::move(funcRef),
           return fptr(static_cast<int>(places.ToInt64()));
         }));
   } else if (name == "max") {
     return FoldMINorMAX(context, std::move(funcRef), Ordering::Greater);
   } else if (name == "max0" || name == "max1") {
     return RewriteSpecificMINorMAX(context, std::move(funcRef));
   } else if (name == "maxexponent") {
     if (auto *sx{UnwrapExpr<Expr<SomeReal>>(args[0])}) {
-      return std::visit(
+      return common::visit(
           [](const auto &x) {
             using TR = typename std::decay_t<decltype(x)>::Result;
             return Expr<T>{Scalar<TR>::MAXEXPONENT};
           },
           sx->u);
     }
   } else if (name == "maxloc") {
     return FoldLocation<WhichLocation::Maxloc, T>(context, std::move(funcRef));
   } else if (name == "maxval") {
     return FoldMaxvalMinval<T>(context, std::move(funcRef),
         RelationalOperator::GT, T::Scalar::Least());
   } else if (name == "merge") {
     return FoldMerge<T>(context, std::move(funcRef));
   } else if (name == "merge_bits") {
     return FoldElementalIntrinsic<T, T, T, T>(
         context, std::move(funcRef), &Scalar<T>::MERGE_BITS);
   } else if (name == "min") {
     return FoldMINorMAX(context, std::move(funcRef), Ordering::Less);
   } else if (name == "min0" || name == "min1") {
     return RewriteSpecificMINorMAX(context, std::move(funcRef));
   } else if (name == "minexponent") {
     if (auto *sx{UnwrapExpr<Expr<SomeReal>>(args[0])}) {
-      return std::visit(
+      return common::visit(
           [](const auto &x) {
             using TR = typename std::decay_t<decltype(x)>::Result;
             return Expr<T>{Scalar<TR>::MINEXPONENT};
           },
           sx->u);
     }
   } else if (name == "minloc") {
     return FoldLocation<WhichLocation::Minloc, T>(context, std::move(funcRef));
return FoldElementalIntrinsic<T, T, T>(context, std::move(funcRef),
               }
               return result.value;
             }));
   } else if (name == "not") {
     return FoldElementalIntrinsic<T, T>(
         context, std::move(funcRef), &Scalar<T>::NOT);
   } else if (name == "precision") {
     if (const auto *cx{UnwrapExpr<Expr<SomeReal>>(args[0])}) {
-      return Expr<T>{std::visit(
+      return Expr<T>{common::visit(
           [](const auto &kx) {
             return Scalar<ResultType<decltype(kx)>>::PRECISION;
           },
           cx->u)};
     } else if (const auto *cx{UnwrapExpr<Expr<SomeComplex>>(args[0])}) {
-      return Expr<T>{std::visit(
+      return Expr<T>{common::visit(
           [](const auto &kx) {
             return Scalar<typename ResultType<decltype(kx)>::Part>::PRECISION;
           },
           cx->u)};
     }
   } else if (name == "product") {
     return FoldProduct<T>(context, std::move(funcRef), Scalar<T>{1});
   } else if (name == "radix") {
     return Expr<T>{2};
   } else if (name == "range") {
     if (const auto *cx{UnwrapExpr<Expr<SomeInteger>>(args[0])}) {
-      return Expr<T>{std::visit(
+      return Expr<T>{common::visit(
           [](const auto &kx) {
             return Scalar<ResultType<decltype(kx)>>::RANGE;
           },
           cx->u)};
     } else if (const auto *cx{UnwrapExpr<Expr<SomeReal>>(args[0])}) {
-      return Expr<T>{std::visit(
+      return Expr<T>{common::visit(
           [](const auto &kx) {
             return Scalar<ResultType<decltype(kx)>>::RANGE;
           },
           cx->u)};
     } else if (const auto *cx{UnwrapExpr<Expr<SomeComplex>>(args[0])}) {
-      return Expr<T>{std::visit(
+      return Expr<T>{common::visit(
           [](const auto &kx) {
             return Scalar<typename ResultType<decltype(kx)>::Part>::RANGE;
           },
           cx->u)};
     }
   } else if (name == "rank") {
     if (const auto *array{UnwrapExpr<Expr<SomeType>>(args[0])}) {
       if (auto named{ExtractNamedEntity(*array)}) {
if (const auto *pdt{context.pdtInstance()}) {
         }
       }
     }
   }
   return AsExpr(std::move(inquiry));
 }
 
 std::optional<std::int64_t> ToInt64(const Expr<SomeInteger> &expr) {
-  return std::visit(
+  return common::visit(
       [](const auto &kindExpr) { return ToInt64(kindExpr); }, expr.u);
 }
 
 std::optional<std::int64_t> ToInt64(const Expr<SomeType> &expr) {
   if (const auto *intExpr{UnwrapExpr<Expr<SomeInteger>>(expr)}) {
     return ToInt64(*intExpr);
   } else {
     return std::nullopt;

flang/lib/Evaluate/fold-logical.cpp

if (name == "all") {
     return FoldElementalIntrinsic<T, LargestInt, LargestInt>(context,
         std::move(funcRef),
         ScalarFunc<T, LargestInt, LargestInt>(
             [&fptr](const Scalar<LargestInt> &i, const Scalar<LargestInt> &j) {
               return Scalar<T>{std::invoke(fptr, i, j)};
             }));
   } else if (name == "btest") {
     if (const auto *ix{UnwrapExpr<Expr<SomeInteger>>(args[0])}) {
-      return std::visit(
+      return common::visit(
           [&](const auto &x) {
             using IT = ResultType<decltype(x)>;
             return FoldElementalIntrinsic<T, IT, SameInt>(context,
                 std::move(funcRef),
                 ScalarFunc<T, IT, SameInt>(
                     [&](const Scalar<IT> &x, const Scalar<SameInt> &pos) {
                       auto posVal{pos.ToInt64()};
                       if (posVal < 0 || posVal >= x.bits) {
if (auto folded{OperandsAreConstants(relation)}) {
     }
     return Expr<LogicalResult>{Constant<LogicalResult>{result}};
   }
   return Expr<LogicalResult>{Relational<SomeType>{std::move(relation)}};
 }
 
 Expr<LogicalResult> FoldOperation(
     FoldingContext &context, Relational<SomeType> &&relation) {
-  return std::visit(
+  return common::visit(
       [&](auto &&x) {
         return Expr<LogicalResult>{FoldOperation(context, std::move(x))};
       },
       std::move(relation.u));
 }
 
 template <int KIND>
 Expr<Type<TypeCategory::Logical, KIND>> FoldOperation(

flang/lib/Evaluate/fold-real.cpp

if (name == "acos" || name == "acosh" || name == "asin" || name == "asinh" ||
     auto one{Scalar<T>::FromInteger(value::Integer<8>{1}).value};
     return FoldProduct<T>(context, std::move(funcRef), one);
   } else if (name == "real" || name == "dble") {
     if (auto *expr{args[0].value().UnwrapExpr()}) {
       return ToReal<KIND>(context, std::move(*expr));
     }
   } else if (name == "scale") {
     if (const auto *byExpr{UnwrapExpr<Expr<SomeInteger>>(args[1])}) {
-      return std::visit(
+      return common::visit(
           [&](const auto &byVal) {
             using TBY = ResultType<decltype(byVal)>;
             return FoldElementalIntrinsic<T, T, TBY>(context,
                 std::move(funcRef),
                 ScalarFunc<T, T, TBY>(
                     [&](const Scalar<T> &x, const Scalar<TBY> &y) -> Scalar<T> {
                       ValueWithRealFlags<Scalar<T>> result{x.
 // MSVC chokes on the keyword "template" here in a call to a

flang/lib/Evaluate/fold.cpp

characteristics::TypeAndShape Fold(
     FoldingContext &context, characteristics::TypeAndShape &&x) {
   x.Rewrite(context);
   return std::move(x);
 }
 
 std::optional<Constant<SubscriptInteger>> GetConstantSubscript(
     FoldingContext &context, Subscript &ss, const NamedEntity &base, int dim) {
   ss = FoldOperation(context, std::move(ss));
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](IndirectSubscriptIntegerExpr &expr)
               -> std::optional<Constant<SubscriptInteger>> {
             if (const auto *constant{
                     UnwrapConstantValue<SubscriptInteger>(expr.value())}) {
               return *constant;
             } else {
               return std::nullopt;

 Triplet FoldOperation(FoldingContext &context, Triplet &&triplet) {
   MaybeExtentExpr lower{triplet.lower()};
   MaybeExtentExpr upper{triplet.upper()};
   return {Fold(context, std::move(lower)), Fold(context, std::move(upper)),
       Fold(context, triplet.stride())};
 }
 
 Subscript FoldOperation(FoldingContext &context, Subscript &&subscript) {
-  return std::visit(common::visitors{
-                        [&](IndirectSubscriptIntegerExpr &&expr) {
-                          expr.value() = Fold(context, std::move(expr.value()));
-                          return Subscript(std::move(expr));
-                        },
-                        [&](Triplet &&triplet) {
-                          return Subscript(
-                              FoldOperation(context, std::move(triplet)));
-                        },
-                    },
+  return common::visit(
+      common::visitors{
+            return Subscript(FoldOperation(context, std::move(triplet)));
       std::move(subscript.u));
 }
 
 ArrayRef FoldOperation(FoldingContext &context, ArrayRef &&arrayRef) {
   NamedEntity base{FoldOperation(context, std::move(arrayRef.base()))};
   for (Subscript &subscript : arrayRef.subscript()) {
     subscript = FoldOperation(context, std::move(subscript));
   }
CoarrayRef FoldOperation(FoldingContext &context, CoarrayRef &&coarrayRef) {
   if (std::optional<Expr<SomeInteger>> team{coarrayRef.team()}) {
     folded.set_team(
         Fold(context, std::move(*team)), coarrayRef.teamIsTeamNumber());
   }
   return folded;
 }
 
 DataRef FoldOperation(FoldingContext &context, DataRef &&dataRef) {
-  return std::visit(common::visitors{
+  return common::visit(common::visitors{
                            [&](SymbolRef symbol) { return DataRef{*symbol}; },
                            [&](auto &&x) {
-                          return DataRef{FoldOperation(context, std::move(x))};
+                             return DataRef{
+                                 FoldOperation(context, std::move(x))};
                            },
                        },
       std::move(dataRef.u));
 }
 
 Substring FoldOperation(FoldingContext &context, Substring &&substring) {
   auto lower{Fold(context, substring.lower())};
   auto upper{Fold(context, substring.upper())};
   if (const DataRef * dataRef{substring.GetParentIf<DataRef>()}) {
     return Substring{FoldOperation(context, DataRef{*dataRef}),

flang/lib/Evaluate/formatting.cpp

llvm::raw_ostream &ActualArgument::AssumedType::AsFortran(
     llvm::raw_ostream &o) const {
   return o << symbol_->name().ToString();
 }
 
 llvm::raw_ostream &ActualArgument::AsFortran(llvm::raw_ostream &o) const {
   if (keyword_) {
     o << keyword_->ToString() << '=';
   }
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const common::CopyableIndirection<Expr<SomeType>> &expr) {
             expr.value().AsFortran(o);
           },
           [&](const AssumedType &assumedType) { assumedType.AsFortran(o); },
           [&](const common::Label &label) { o << '*' << label; },
       },
       u_);
if (auto n{GetScalarConstantValue<T>(x)}) {
       if (n->IsNegative()) {
         return Precedence::Negate;
       }
     }
   }
   return Precedence::Top;
 }
 template <typename T> static Precedence ToPrecedence(const Expr<T> &expr) {
-  return std::visit([](const auto &x) { return ToPrecedence(x); }, expr.u);
+  return common::visit([](const auto &x) { return ToPrecedence(x); }, expr.u);
 }
 
 template <typename T> static bool IsNegatedScalarConstant(const Expr<T> &expr) {
   static constexpr TypeCategory cat{T::category};
   if constexpr (cat == TypeCategory::Integer || cat == TypeCategory::Real) {
     if (auto n{GetScalarConstantValue<T>(expr)}) {
       return n->IsNegative();
     }
   }
   return false;
 }
 
 template <TypeCategory CAT>
 static bool IsNegatedScalarConstant(const Expr<SomeKind<CAT>> &expr) {
-  return std::visit(
+  return common::visit(
       [](const auto &x) { return IsNegatedScalarConstant(x); }, expr.u);
 }
 
 struct OperatorSpelling {
   const char *prefix{""}, *infix{","}, *suffix{""};
 };
 
 template <typename A> constexpr OperatorSpelling SpellOperator(const A &) {
if constexpr (TO::category == TypeCategory::Character) {
     this->left().AsFortran(o << "cmplx(");
   } else {
     this->left().AsFortran(o << "logical(");
   }
   return o << ",kind=" << TO::kind << ')';
 }
 
 llvm::raw_ostream &Relational<SomeType>::AsFortran(llvm::raw_ostream &o) const {
-  std::visit([&](const auto &rel) { rel.AsFortran(o); }, u);
+  common::visit([&](const auto &rel) { rel.AsFortran(o); }, u);
   return o;
 }
 
 template <typename T>
 llvm::raw_ostream &EmitArray(llvm::raw_ostream &o, const Expr<T> &expr) {
   return expr.AsFortran(o);
 }
 

 }
 
 template <typename T>
 llvm::raw_ostream &EmitArray(
     llvm::raw_ostream &o, const ArrayConstructorValues<T> &values) {
   const char *sep{""};
   for (const auto &value : values) {
     o << sep;
-    std::visit([&](const auto &x) { EmitArray(o, x); }, value.u);
+    common::visit([&](const auto &x) { EmitArray(o, x); }, value.u);
     sep = ",";
   }
   return o;
 }
 
 template <typename T>
 llvm::raw_ostream &ArrayConstructor<T>::AsFortran(llvm::raw_ostream &o) const {
   o << '[' << GetType().AsFortran() << "::";
std::string ExpressionBase<RESULT>::AsFortran() const {
   llvm::raw_string_ostream ss{buf};
   AsFortran(ss);
   return ss.str();
 }
 
 template <typename RESULT>
 llvm::raw_ostream &ExpressionBase<RESULT>::AsFortran(
     llvm::raw_ostream &o) const {
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [&](const BOZLiteralConstant &x) {
                       o << "z'" << x.Hexadecimal() << "'";
                     },
                     [&](const NullPointer &) { o << "NULL()"; },
                     [&](const common::CopyableIndirection<Substring> &s) {
                       s.value().AsFortran(o);
                     },
                     [&](const ImpliedDoIndex &i) { o << i.name.ToString(); },
                     [&](const auto &x) { x.AsFortran(o); },
                 },
       derived().u);
   return o;
 }
 
 llvm::raw_ostream &StructureConstructor::AsFortran(llvm::raw_ostream &o) const {
   o << DerivedTypeSpecAsFortran(result_.derivedTypeSpec());
   if (values_.empty()) {
     o << '(';

 template <typename A>
 llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const std::shared_ptr<A> &p) {
   CHECK(p);
   return EmitVar(o, *p);
 }
 
 template <typename... A>
 llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const std::variant<A...> &u) {
-  std::visit([&](const auto &x) { EmitVar(o, x); }, u);
+  common::visit([&](const auto &x) { EmitVar(o, x); }, u);
   return o;
 }
 
 llvm::raw_ostream &BaseObject::AsFortran(llvm::raw_ostream &o) const {
   return EmitVar(o, u);
 }
 
 llvm::raw_ostream &TypeParamInquiry::AsFortran(llvm::raw_ostream &o) const {
   if (base_) {
     base_.value().AsFortran(o) << '%';
   }
   return EmitVar(o, parameter_);
 }
 
 llvm::raw_ostream &Component::AsFortran(llvm::raw_ostream &o) const {
   base_.value().AsFortran(o);
   return EmitVar(o << '%', symbol_);
 }
 
 llvm::raw_ostream &NamedEntity::AsFortran(llvm::raw_ostream &o) const {
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [&](SymbolRef s) { EmitVar(o, s); },
                     [&](const Component &c) { c.AsFortran(o); },
                 },
       u_);
   return o;
 }
 
 llvm::raw_ostream &Triplet::AsFortran(llvm::raw_ostream &o) const {
   EmitVar(o, lower_) << ':';
   EmitVar(o, upper_);
   EmitVar(o << ':', stride_.value());

 }
 
 llvm::raw_ostream &ProcedureDesignator::AsFortran(llvm::raw_ostream &o) const {
   return EmitVar(o, u);
 }
 
 template <typename T>
 llvm::raw_ostream &Designator<T>::AsFortran(llvm::raw_ostream &o) const {
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [&](SymbolRef symbol) { EmitVar(o, symbol); },
                     [&](const auto &x) { x.AsFortran(o); },
                 },
       u);
   return o;
 }
 
 llvm::raw_ostream &DescriptorInquiry::AsFortran(llvm::raw_ostream &o) const {
   switch (field_) {
   case Field::LowerBound:
     o << "lbound(";
if (field_ == Field::Len) {
     if (dimension_ >= 0) {
       o << ",dim=" << (dimension_ + 1);
     }
   }
   return o << ",kind=" << DescriptorInquiry::Result::kind << ")";
 }
 
 llvm::raw_ostream &Assignment::AsFortran(llvm::raw_ostream &o) const {
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const Assignment::Intrinsic &) {
             rhs.AsFortran(lhs.AsFortran(o) << '=');
           },
           [&](const ProcedureRef &proc) { proc.AsFortran(o << "CALL "); },
           [&](const BoundsSpec &bounds) {
             lhs.AsFortran(o);
             if (!bounds.empty()) {

flang/lib/Evaluate/shape.cpp

 
 MaybeExtentExpr GetExtent(
     FoldingContext &context, const NamedEntity &base, int dimension) {
   return Fold(context, GetExtent(base, dimension));
 }
 
 MaybeExtentExpr GetExtent(
     const Subscript &subscript, const NamedEntity &base, int dimension) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const Triplet &triplet) -> MaybeExtentExpr {
             MaybeExtentExpr upper{triplet.upper()};
             if (!upper) {
               upper = GetUBOUND(base, dimension);
             }
             MaybeExtentExpr lower{triplet.lower()};
             if (!lower) {

 
 Shape GetUBOUNDs(FoldingContext &context, const NamedEntity &base) {
   return Fold(context, GetUBOUNDs(&context, base));
 }
 
 Shape GetUBOUNDs(const NamedEntity &base) { return GetUBOUNDs(nullptr, base); }
 
 auto GetShapeHelper::operator()(const Symbol &symbol) const -> Result {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const semantics::ObjectEntityDetails &object) {
             if (IsImpliedShape(symbol) && object.init()) {
               return (*this)(object.init());
             } else if (IsAssumedRank(symbol)) {
               return Result{};
             } else {
               int n{object.shape().Rank()};

flang/lib/Evaluate/tools.cpp

std::optional<Expr<SomeType>> AsGenericExpr(DataRef &&ref) {
   return std::nullopt;
 }
 
 std::optional<Expr<SomeType>> AsGenericExpr(const Symbol &symbol) {
   return AsGenericExpr(DataRef{symbol});
 }
 
 Expr<SomeType> Parenthesize(Expr<SomeType> &&expr) {
-  return std::visit(
+  return common::visit(
       [&](auto &&x) {
         using T = std::decay_t<decltype(x)>;
         if constexpr (common::HasMember<T, TypelessExpression>) {
           return expr; // no parentheses around typeless
         } else if constexpr (std::is_same_v<T, Expr<SomeDerived>>) {
           return AsGenericExpr(Parentheses<SomeDerived>{std::move(x)});
         } else {
-          return std::visit(
+          return common::visit(
               [](auto &&y) {
                 using T = ResultType<decltype(y)>;
                 return AsGenericExpr(Parentheses<T>{std::move(y)});
               },
               std::move(x.u));
         }
       },
       std::move(expr.u));
 }
 
 std::optional<DataRef> ExtractDataRef(
     const ActualArgument &arg, bool intoSubstring) {
   if (const Expr<SomeType> *expr{arg.UnwrapExpr()}) {
     return ExtractDataRef(*expr, intoSubstring);
   } else {
     return std::nullopt;
   }
 }
 
 std::optional<DataRef> ExtractSubstringBase(const Substring &substring) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const DataRef &x) -> std::optional<DataRef> { return x; },
           [&](const StaticDataObject::Pointer &) -> std::optional<DataRef> {
             return std::nullopt;
           },
       },
       substring.parent());
 }
auto IsVariableHelper::operator()(const ProcedureDesignator &x) const
   }
   return false;
 }
 
 // Conversions of COMPLEX component expressions to REAL.
 ConvertRealOperandsResult ConvertRealOperands(
     parser::ContextualMessages &messages, Expr<SomeType> &&x,
     Expr<SomeType> &&y, int defaultRealKind) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](Expr<SomeInteger> &&ix,
               Expr<SomeInteger> &&iy) -> ConvertRealOperandsResult {
             // Can happen in a CMPLX() constructor.  Per F'2018,
             // both integer operands are converted to default REAL.
             return {AsSameKindExprs<TypeCategory::Real>(
                 ConvertToKind<TypeCategory::Real>(
                     defaultRealKind, std::move(ix)),
std::optional<Expr<SomeType>> Package(
   return NoExpr();
 }
 
 // Mixed REAL+INTEGER operations.  REAL**INTEGER is a special case that
 // does not require conversion of the exponent expression.
 template <template <typename> class OPR>
 std::optional<Expr<SomeType>> MixedRealLeft(
     Expr<SomeReal> &&rx, Expr<SomeInteger> &&iy) {
-  return Package(std::visit(
+  return Package(common::visit(
       [&](auto &&rxk) -> Expr<SomeReal> {
         using resultType = ResultType<decltype(rxk)>;
         if constexpr (std::is_same_v<OPR<resultType>, Power<resultType>>) {
           return AsCategoryExpr(
               RealToIntPower<resultType>{std::move(rxk), std::move(iy)});
         }
         // G++ 8.1.0 emits bogus warnings about missing return statements if
         // this statement is wrapped in an "else", as it should be.
         return AsCategoryExpr(OPR<resultType>{
             std::move(rxk), ConvertToType<resultType>(std::move(iy))});
       },
       std::move(rx.u)));
 }
 
 std::optional<Expr<SomeComplex>> ConstructComplex(
     parser::ContextualMessages &messages, Expr<SomeType> &&real,
     Expr<SomeType> &&imaginary, int defaultRealKind) {
   if (auto converted{ConvertRealOperands(
           messages, std::move(real), std::move(imaginary), defaultRealKind)}) {
-    return {std::visit(
+    return {common::visit(
         [](auto &&pair) {
           return MakeComplex(std::move(pair[0]), std::move(pair[1]));
         },
         std::move(*converted))};
   }
   return std::nullopt;
 }
 
 std::optional<Expr<SomeComplex>> ConstructComplex(
     parser::ContextualMessages &messages, std::optional<Expr<SomeType>> &&real,
     std::optional<Expr<SomeType>> &&imaginary, int defaultRealKind) {
   if (auto parts{common::AllPresent(std::move(real), std::move(imaginary))}) {
     return ConstructComplex(messages, std::get<0>(std::move(*parts)),
         std::get<1>(std::move(*parts)), defaultRealKind);
   }
   return std::nullopt;
 }
 
 Expr<SomeReal> GetComplexPart(const Expr<SomeComplex> &z, bool isImaginary) {
-  return std::visit(
+  return common::visit(
       [&](const auto &zk) {
         static constexpr int kind{ResultType<decltype(zk)>::kind};
         return AsCategoryExpr(ComplexComponent<kind>{isImaginary, zk});
       },
       z.u);
 }
 
 // Convert REAL to COMPLEX of the same kind. Preserving the real operand kind
 // and then applying complex operand promotion rules allows the result to have
 // the highest precision of REAL and COMPLEX operands as required by Fortran
 // 2018 10.9.1.3.
 Expr<SomeComplex> PromoteRealToComplex(Expr<SomeReal> &&someX) {
-  return std::visit(
+  return common::visit(
       [](auto &&x) {
         using RT = ResultType<decltype(x)>;
         return AsCategoryExpr(ComplexConstructor<RT::kind>{
             std::move(x), AsExpr(Constant<RT>{Scalar<RT>{}})});
       },
       std::move(someX.u));
 }
 
if constexpr (std::is_same_v<OPR<LargestReal>, Add<LargestReal>> ||
     if (auto parts{common::AllPresent(std::move(rr), std::move(ri))}) {
       return Package(ConstructComplex(messages, std::get<0>(std::move(*parts)),
           std::get<1>(std::move(*parts)), defaultRealKind));
     }
   } else if constexpr (RCAT == TypeCategory::Integer &&
       std::is_same_v<OPR<LargestReal>, Power<LargestReal>>) {
     // COMPLEX**INTEGER is a special case that doesn't convert the exponent.
     static_assert(RCAT == TypeCategory::Integer);
-    return Package(std::visit(
+    return Package(common::visit(
         [&](auto &&zxk) {
           using Ty = ResultType<decltype(zxk)>;
           return AsCategoryExpr(
               AsExpr(RealToIntPower<Ty>{std::move(zxk), std::move(iry)}));
         },
         std::move(zx.u)));
   } else {
     // (a,b) ** x -> (a,b) ** (x,0)

 
 // N.B. When a "typeless" BOZ literal constant appears as one (not both!) of
 // the operands to a dyadic operation where one is permitted, it assumes the
 // type and kind of the other operand.
 template <template <typename> class OPR>
 std::optional<Expr<SomeType>> NumericOperation(
     parser::ContextualMessages &messages, Expr<SomeType> &&x,
     Expr<SomeType> &&y, int defaultRealKind) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](Expr<SomeInteger> &&ix, Expr<SomeInteger> &&iy) {
             return Package(PromoteAndCombine<OPR, TypeCategory::Integer>(
                 std::move(ix), std::move(iy)));
           },
           [](Expr<SomeReal> &&rx, Expr<SomeReal> &&ry) {
             return Package(PromoteAndCombine<OPR, TypeCategory::Real>(
                 std::move(rx), std::move(ry)));
           },
           // Mixed REAL/INTEGER operations
           [](Expr<SomeReal> &&rx, Expr<SomeInteger> &&iy) {
             return MixedRealLeft<OPR>(std::move(rx), std::move(iy));
           },
           [](Expr<SomeInteger> &&ix, Expr<SomeReal> &&ry) {
-            return Package(std::visit(
+            return Package(common::visit(
                 [&](auto &&ryk) -> Expr<SomeReal> {
                   using resultType = ResultType<decltype(ryk)>;
                   return AsCategoryExpr(
                       OPR<resultType>{ConvertToType<resultType>(std::move(ix)),
                           std::move(ryk)});
                 },
                 std::move(ry.u)));
           },
template std::optional<Expr<SomeType>> NumericOperation<Add>(
     parser::ContextualMessages &, Expr<SomeType> &&, Expr<SomeType> &&,
     int defaultRealKind);
 template std::optional<Expr<SomeType>> NumericOperation<Subtract>(
     parser::ContextualMessages &, Expr<SomeType> &&, Expr<SomeType> &&,
     int defaultRealKind);
 
 std::optional<Expr<SomeType>> Negation(
     parser::ContextualMessages &messages, Expr<SomeType> &&x) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](BOZLiteralConstant &&) {
             messages.Say("BOZ literal cannot be negated"_err_en_US);
             return NoExpr();
           },
           [&](NullPointer &&) {
             messages.Say("NULL() cannot be negated"_err_en_US);
             return NoExpr();
return common::visit(
             messages.Say("Operand cannot be negated"_err_en_US);
             return NoExpr();
           },
       },
       std::move(x.u));
 }
 
 Expr<SomeLogical> LogicalNegation(Expr<SomeLogical> &&x) {
-  return std::visit(
+  return common::visit(
       [](auto &&xk) { return AsCategoryExpr(LogicalNegation(std::move(xk))); },
       std::move(x.u));
 }
 
 template <TypeCategory CAT>
 Expr<LogicalResult> PromoteAndRelate(
     RelationalOperator opr, Expr<SomeKind<CAT>> &&x, Expr<SomeKind<CAT>> &&y) {
-  return std::visit(
+  return common::visit(
       [=](auto &&xy) {
         return PackageRelation(opr, std::move(xy[0]), std::move(xy[1]));
       },
       AsSameKindExprs(std::move(x), std::move(y)));
 }
 
 std::optional<Expr<LogicalResult>> Relate(parser::ContextualMessages &messages,
     RelationalOperator opr, Expr<SomeType> &&x, Expr<SomeType> &&y) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [=](Expr<SomeInteger> &&ix,
               Expr<SomeInteger> &&iy) -> std::optional<Expr<LogicalResult>> {
             return PromoteAndRelate(opr, std::move(ix), std::move(iy));
           },
           [=](Expr<SomeReal> &&rx,
               Expr<SomeReal> &&ry) -> std::optional<Expr<LogicalResult>> {
             return PromoteAndRelate(opr, std::move(rx), std::move(ry));
return common::visit(
             return Relate(messages, opr,
                 AsGenericExpr(ConvertTo(zy, std::move(ix))), std::move(y));
           },
           [&](Expr<SomeReal> &&rx, Expr<SomeComplex> &&zy) {
             return Relate(messages, opr,
                 AsGenericExpr(ConvertTo(zy, std::move(rx))), std::move(y));
           },
           [&](Expr<SomeCharacter> &&cx, Expr<SomeCharacter> &&cy) {
-            return std::visit(
+            return common::visit(
                 [&](auto &&cxk,
                     auto &&cyk) -> std::optional<Expr<LogicalResult>> {
                   using Ty = ResultType<decltype(cxk)>;
                   if constexpr (std::is_same_v<Ty, ResultType<decltype(cyk)>>) {
                     return PackageRelation(opr, std::move(cxk), std::move(cyk));
                   } else {
                     messages.Say(
                         "CHARACTER operands do not have same KIND"_err_en_US);
return common::visit(
           },
       },
       std::move(x.u), std::move(y.u));
 }
 
 Expr<SomeLogical> BinaryLogicalOperation(
     LogicalOperator opr, Expr<SomeLogical> &&x, Expr<SomeLogical> &&y) {
   CHECK(opr != LogicalOperator::Not);
-  return std::visit(
+  return common::visit(
       [=](auto &&xy) {
         using Ty = ResultType<decltype(xy[0])>;
         return Expr<SomeLogical>{BinaryLogicalOperation<Ty::kind>(
             opr, std::move(xy[0]), std::move(xy[1]))};
       },
       AsSameKindExprs(std::move(x), std::move(y)));
 }
 
 template <TypeCategory TO>
 std::optional<Expr<SomeType>> ConvertToNumeric(int kind, Expr<SomeType> &&x) {
   static_assert(common::IsNumericTypeCategory(TO));
-  return std::visit(
+  return common::visit(
       [=](auto &&cx) -> std::optional<Expr<SomeType>> {
         using cxType = std::decay_t<decltype(cx)>;
         if constexpr (!common::HasMember<cxType, TypelessExpression>) {
           if constexpr (IsNumericTypeCategory(ResultType<cxType>::category)) {
             return Expr<SomeType>{ConvertToKind<TO>(kind, std::move(cx))};
           }
         }
         return std::nullopt;
case TypeCategory::Real:
     return ConvertToNumeric<TypeCategory::Real>(type.kind(), std::move(x));
   case TypeCategory::Complex:
     return ConvertToNumeric<TypeCategory::Complex>(type.kind(), std::move(x));
   case TypeCategory::Character:
     if (auto *cx{UnwrapExpr<Expr<SomeCharacter>>(x)}) {
       auto converted{
           ConvertToKind<TypeCategory::Character>(type.kind(), std::move(*cx))};
       if (auto length{type.GetCharLength()}) {
-        converted = std::visit(
+        converted = common::visit(
             [&](auto &&x) {
               using Ty = std::decay_t<decltype(x)>;
               using CharacterType = typename Ty::Result;
               return Expr<SomeCharacter>{
                   Expr<CharacterType>{SetLength<CharacterType::kind>{
                       std::move(x), std::move(*length)}}};
             },
             std::move(converted.u));
bool IsProcedure(const Expr<SomeType> &expr) {
   return std::holds_alternative<ProcedureDesignator>(expr.u);
 }
 bool IsFunction(const Expr<SomeType> &expr) {
   const auto *designator{std::get_if<ProcedureDesignator>(&expr.u)};
   return designator && designator->GetType().has_value();
 }
 
 bool IsProcedurePointerTarget(const Expr<SomeType> &expr) {
-  return std::visit(common::visitors{
+  return common::visit(common::visitors{
                            [](const NullPointer &) { return true; },
                            [](const ProcedureDesignator &) { return true; },
                            [](const ProcedureRef &) { return true; },
                            [&](const auto &) {
                              const Symbol *last{GetLastSymbol(expr)};
                              return last && IsProcedurePointer(*last);
                            },
                        },
       expr.u);
 }
 
 template <typename A> inline const ProcedureRef *UnwrapProcedureRef(const A &) {
   return nullptr;
 }
 
 template <typename T>
 inline const ProcedureRef *UnwrapProcedureRef(const FunctionRef<T> &func) {
   return &func;
 }
 
 template <typename T>
 inline const ProcedureRef *UnwrapProcedureRef(const Expr<T> &expr) {
-  return std::visit(
+  return common::visit(
       [](const auto &x) { return UnwrapProcedureRef(x); }, expr.u);
 }
 
 // IsObjectPointer()
 bool IsObjectPointer(const Expr<SomeType> &expr, FoldingContext &context) {
   if (IsNullPointer(expr)) {
     return true;
   } else if (IsProcedurePointerTarget(expr)) {
return intrinsic &&
         intrinsic->characteristics.value().attrs.test(
             characteristics::Procedure::Attr::NullPointer);
   }
   bool operator()(const NullPointer &) const { return true; }
   template <typename T> bool operator()(const Parentheses<T> &x) const {
     return (*this)(x.left());
   }
   template <typename T> bool operator()(const Expr<T> &x) const {
-    return std::visit(*this, x.u);
+    return common::visit(*this, x.u);
   }
 };
 
 bool IsNullPointer(const Expr<SomeType> &expr) {
   return IsNullPointerHelper{}(expr);
 }
 
 // GetSymbolVector()

 }
 static const Symbol *GetLastPointerSymbol(const ArrayRef &x) {
   return GetLastPointerSymbol(x.base());
 }
 static const Symbol *GetLastPointerSymbol(const CoarrayRef &x) {
   return nullptr;
 }
 const Symbol *GetLastPointerSymbol(const DataRef &x) {
-  return std::visit([](const auto &y) { return GetLastPointerSymbol(y); }, x.u);
+  return common::visit(
+      [](const auto &y) { return GetLastPointerSymbol(y); }, x.u);
 }
 
 template <TypeCategory TO, TypeCategory FROM>
 static std::optional<Expr<SomeType>> DataConstantConversionHelper(
     FoldingContext &context, const DynamicType &toType,
     const Expr<SomeType> &expr) {
   DynamicType sizedType{FROM, toType.kind()};
   if (auto sized{
           Fold(context, ConvertToType(sizedType, Expr<SomeType>{expr}))}) {
     if (const auto *someExpr{UnwrapExpr<Expr<SomeKind<FROM>>>(*sized)}) {
-      return std::visit(
+      return common::visit(
           [](const auto &w) -> std::optional<Expr<SomeType>> {
             using FromType = typename std::decay_t<decltype(w)>::Result;
             static constexpr int kind{FromType::kind};
             if constexpr (IsValidKindOfIntrinsicType(TO, kind)) {
               if (const auto *fromConst{UnwrapExpr<Constant<FromType>>(w)}) {
                 using FromWordType = typename FromType::Scalar;
                 using LogicalType = value::Logical<FromWordType::bits>;
                 using ElementType =

 bool IsPureProcedure(const Scope &scope) {
   const Symbol *symbol{scope.GetSymbol()};
   return symbol && IsPureProcedure(*symbol);
 }
 
 bool IsFunction(const Symbol &symbol) {
   const Symbol &ultimate{symbol.GetUltimate()};
   return ultimate.test(Symbol::Flag::Function) ||
-      std::visit(common::visitors{
-                     [](const SubprogramDetails &x) { return x.isFunction(); },
-                     [](const ProcEntityDetails &x) {
-                       const auto &ifc{x.interface()};
-                       return ifc.type() ||
-                           (ifc.symbol() && IsFunction(*ifc.symbol()));
-                     },
-                     [](const ProcBindingDetails &x) {
-                       return IsFunction(x.symbol());
-                     },
-                     [](const auto &) { return false; },
-                 },
+      common::visit(
+          common::visitors{
           ultimate.details());
 }
 
 bool IsFunction(const Scope &scope) {
   const Symbol *symbol{scope.GetSymbol()};
   return symbol && IsFunction(*symbol);
 }
 
 bool IsProcedure(const Symbol &symbol) {
-  return std::visit(common::visitors{
+  return common::visit(common::visitors{
                            [](const SubprogramDetails &) { return true; },
                            [](const SubprogramNameDetails &) { return true; },
                            [](const ProcEntityDetails &) { return true; },
                            [](const GenericDetails &) { return true; },
                            [](const ProcBindingDetails &) { return true; },
                            [](const auto &) { return false; },
                        },
       symbol.GetUltimate().details());
 }
 
 bool IsProcedure(const Scope &scope) {
   const Symbol *symbol{scope.GetSymbol()};
   return symbol && IsProcedure(*symbol);
 }
 
return true; // bare SAVE statement
              block && block->attrs().test(Attr::SAVE)) {
     return true; // in COMMON with SAVE
   } else {
     return false;
   }
 }
 
 bool IsDummy(const Symbol &symbol) {
-  return std::visit(
+  return common::visit(
       common::visitors{[](const EntityDetails &x) { return x.isDummy(); },
           [](const ObjectEntityDetails &x) { return x.isDummy(); },
           [](const ProcEntityDetails &x) { return x.isDummy(); },
           [](const SubprogramDetails &x) { return x.isDummy(); },
           [](const auto &) { return false; }},
       ResolveAssociations(symbol).details());
 }
 

 
 static const Symbol *FindFunctionResult(
     const Symbol &original, UnorderedSymbolSet &seen) {
   const Symbol &root{GetAssociationRoot(original)};
   ;
   if (!seen.insert(root).second) {
     return nullptr; // don't loop
   }
-  return std::visit(
+  return common::visit(
       common::visitors{[](const SubprogramDetails &subp) {
                          return subp.isFunction() ? &subp.result() : nullptr;
                        },
           [&](const ProcEntityDetails &proc) {
             const Symbol *iface{proc.interface().symbol()};
             return iface ? FindFunctionResult(*iface, seen) : nullptr;
           },
           [&](const ProcBindingDetails &binding) {

flang/lib/Evaluate/type.cpp

 static bool IsDescriptor(const ProcEntityDetails &details) {
   // A procedure pointer or dummy procedure must be & is a descriptor if
   // and only if it requires a static link.
   // TODO: refine this placeholder
   return details.HasExplicitInterface();
 }
 
 bool IsDescriptor(const Symbol &symbol) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const ObjectEntityDetails &d) {
             return IsAllocatableOrPointer(symbol) || IsDescriptor(d);
           },
           [&](const ProcEntityDetails &d) {
             return (symbol.attrs().test(Attr::POINTER) ||
                        symbol.attrs().test(Attr::EXTERNAL)) &&
                 IsDescriptor(d);

flang/lib/Evaluate/variable.cpp

Substring &Substring::set_lower(Expr<SubscriptInteger> &&expr) {
   lower_.emplace(std::move(expr));
   return *this;
 }
 
 std::optional<Expr<SubscriptInteger>> Substring::upper() const {
   if (upper_) {
     return upper_.value().value();
   } else {
-    return std::visit(
+    return common::visit(
         common::visitors{
             [](const DataRef &dataRef) { return dataRef.LEN(); },
             [](const StaticDataObject::Pointer &object)
                 -> std::optional<Expr<SubscriptInteger>> {
               return AsExpr(Constant<SubscriptInteger>{object->data().size()});
             },
         },
         parent_);
if (auto expr{AsGenericExpr(DataRef{*dataRef})}) {
         if (const auto *value{UnwrapExpr<Expr<SomeCharacter>>(folded)}) {
           strings = *value;
         }
       }
     }
   }
   std::optional<Expr<SomeCharacter>> result;
   if (strings) {
-    result = std::visit(
+    result = common::visit(
         [&](const auto &expr) -> std::optional<Expr<SomeCharacter>> {
           using Type = typename std::decay_t<decltype(expr)>::Result;
           if (const auto *cc{std::get_if<Constant<Type>>(&expr.u)}) {
             if (auto substr{cc->Substring(*lbi, *ubi)}) {
               return Expr<SomeCharacter>{Expr<Type>{*substr}};
             }
           }
           return std::nullopt;
static std::optional<Expr<SubscriptInteger>> SymbolLEN(const Symbol &symbol) {
   if (IsDescriptor(ultimate) && !ultimate.owner().IsDerivedType()) {
     return Expr<SubscriptInteger>{
         DescriptorInquiry{NamedEntity{symbol}, DescriptorInquiry::Field::Len}};
   }
   return std::nullopt;
 }
 
 std::optional<Expr<SubscriptInteger>> BaseObject::LEN() const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const Symbol &symbol) { return SymbolLEN(symbol); },
           [](const StaticDataObject::Pointer &object)
               -> std::optional<Expr<SubscriptInteger>> {
             return AsExpr(Constant<SubscriptInteger>{object->data().size()});
           },
       },
       u);
std::optional<Expr<SubscriptInteger>> ArrayRef::LEN() const {
   return base_.LEN();
 }
 
 std::optional<Expr<SubscriptInteger>> CoarrayRef::LEN() const {
   return SymbolLEN(GetLastSymbol());
 }
 
 std::optional<Expr<SubscriptInteger>> DataRef::LEN() const {
-  return std::visit(common::visitors{
+  return common::visit(common::visitors{
                            [](SymbolRef symbol) { return SymbolLEN(symbol); },
                            [](const auto &x) { return x.LEN(); },
                        },
       u);
 }
 
 std::optional<Expr<SubscriptInteger>> Substring::LEN() const {
   if (auto top{upper()}) {
     return AsExpr(Extremum<SubscriptInteger>{Ordering::Greater,
         AsExpr(Constant<SubscriptInteger>{0}),
         *std::move(top) - lower() + AsExpr(Constant<SubscriptInteger>{1})});
   } else {
     return std::nullopt;
   }
 }
 
 template <typename T>
 std::optional<Expr<SubscriptInteger>> Designator<T>::LEN() const {
   if constexpr (T::category == TypeCategory::Character) {
-    return std::visit(common::visitors{
+    return common::visit(common::visitors{
                              [](SymbolRef symbol) { return SymbolLEN(symbol); },
                              [](const auto &x) { return x.LEN(); },
                          },
         u);
   } else {
     common::die("Designator<non-char>::LEN() called");
     return std::nullopt;
   }
 }
 
 std::optional<Expr<SubscriptInteger>> ProcedureDesignator::LEN() const {
   using T = std::optional<Expr<SubscriptInteger>>;
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](SymbolRef symbol) -> T { return SymbolLEN(symbol); },
           [](const common::CopyableIndirection<Component> &c) -> T {
             return c.value().LEN();
           },
           [](const SpecificIntrinsic &i) -> T {
             // Some cases whose results' lengths can be determined
             // from the lengths of their arguments are handled in
             // ProcedureRef::LEN() before coming here.
             if (const auto &result{i.characteristics.value().functionResult}) {
               if (const auto *type{result->GetTypeAndShape()}) {
                 if (auto length{type->type().GetCharLength()}) {
                   return std::move(*length);
                 }
               }
             }
             return std::nullopt;
           },
       },
       u);
 }
 
 // Rank()
 int BaseObject::Rank() const {
-  return std::visit(common::visitors{
+  return common::visit(common::visitors{
                            [](SymbolRef symbol) { return symbol->Rank(); },
                            [](const StaticDataObject::Pointer &) { return 0; },
                        },
       u);
 }
 
 int Component::Rank() const {
   if (int rank{symbol_->Rank()}; rank > 0) {
     return rank;
   }
   return base().Rank();
 }
 
 int NamedEntity::Rank() const {
-  return std::visit(common::visitors{
+  return common::visit(common::visitors{
                            [](const SymbolRef s) { return s->Rank(); },
                            [](const Component &c) { return c.Rank(); },
                        },
       u_);
 }
 
 int Subscript::Rank() const {
-  return std::visit(common::visitors{
+  return common::visit(common::visitors{
                            [](const IndirectSubscriptIntegerExpr &x) {
                              return x.value().Rank();
                            },
                            [](const Triplet &) { return 1; },
                        },
       u);
 }
 
 int ArrayRef::Rank() const {
   int rank{0};
   for (const auto &expr : subscript_) {
     rank += expr.Rank();
   }
if (!subscript_.empty()) {
     }
     return rank;
   } else {
     return base_.back()->Rank();
   }
 }
 
 int DataRef::Rank() const {
-  return std::visit(common::visitors{
+  return common::visit(common::visitors{
                            [](SymbolRef symbol) { return symbol->Rank(); },
                            [](const auto &x) { return x.Rank(); },
                        },
       u);
 }
 
 int Substring::Rank() const {
-  return std::visit(common::visitors{
-                        [](const DataRef &dataRef) { return dataRef.Rank(); },
-                        [](const StaticDataObject::Pointer &) { return 0; },
-                    },
+  return common::visit(
+      common::visitors{
       parent_);
 }
 
 int ComplexPart::Rank() const { return complex_.Rank(); }
 
 template <typename T> int Designator<T>::Rank() const {
-  return std::visit(common::visitors{
+  return common::visit(common::visitors{
                            [](SymbolRef symbol) { return symbol->Rank(); },
                            [](const auto &x) { return x.Rank(); },
                        },
       u);
 }
 
 // GetBaseObject(), GetFirstSymbol(), GetLastSymbol(), &c.
 const Symbol &Component::GetFirstSymbol() const {
   return base_.value().GetFirstSymbol();
 }
 
 const Symbol &NamedEntity::GetFirstSymbol() const {
-  return std::visit(common::visitors{
+  return common::visit(common::visitors{
                            [](SymbolRef s) -> const Symbol & { return s; },
                            [](const Component &c) -> const Symbol & {
                              return c.GetFirstSymbol();
                            },
                        },
       u_);
 }
 
 const Symbol &NamedEntity::GetLastSymbol() const {
-  return std::visit(common::visitors{
+  return common::visit(common::visitors{
                            [](SymbolRef s) -> const Symbol & { return s; },
                            [](const Component &c) -> const Symbol & {
                              return c.GetLastSymbol();
                            },
                        },
       u_);
 }
 
 const Component *NamedEntity::UnwrapComponent() const {
-  return std::visit(common::visitors{
-                        [](SymbolRef) -> const Component * { return nullptr; },
-                        [](const Component &c) { return &c; },
-                    },
+  return common::visit(
+      common::visitors{
       u_);
 }
 
 Component *NamedEntity::UnwrapComponent() {
-  return std::visit(common::visitors{
+  return common::visit(common::visitors{
                            [](SymbolRef &) -> Component * { return nullptr; },
                            [](Component &c) { return &c; },
                        },
       u_);
 }
 
 const Symbol &ArrayRef::GetFirstSymbol() const {
   return base_.GetFirstSymbol();
 }
 
 const Symbol &ArrayRef::GetLastSymbol() const { return base_.GetLastSymbol(); }
 
 const Symbol &DataRef::GetFirstSymbol() const {
-  return *std::visit(common::visitors{
+  return *common::visit(common::visitors{
                             [](SymbolRef symbol) { return &*symbol; },
                             [](const auto &x) { return &x.GetFirstSymbol(); },
                         },
       u);
 }
 
 const Symbol &DataRef::GetLastSymbol() const {
-  return *std::visit(common::visitors{
+  return *common::visit(common::visitors{
                             [](SymbolRef symbol) { return &*symbol; },
                             [](const auto &x) { return &x.GetLastSymbol(); },
                         },
       u);
 }
 
 BaseObject Substring::GetBaseObject() const {
-  return std::visit(common::visitors{
+  return common::visit(common::visitors{
                            [](const DataRef &dataRef) {
                              return BaseObject{dataRef.GetFirstSymbol()};
                            },
                            [](StaticDataObject::Pointer pointer) {
                              return BaseObject{std::move(pointer)};
                            },
                        },
       parent_);
 }
 
 const Symbol *Substring::GetLastSymbol() const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const DataRef &dataRef) { return &dataRef.GetLastSymbol(); },
           [](const auto &) -> const Symbol * { return nullptr; },
       },
       parent_);
 }
 
 template <typename T> BaseObject Designator<T>::GetBaseObject() const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](SymbolRef symbol) { return BaseObject{symbol}; },
           [](const Substring &sstring) { return sstring.GetBaseObject(); },
           [](const auto &x) {
 #if !__clang__ && __GNUC__ == 7 && __GNUC_MINOR__ == 2
             if constexpr (std::is_same_v<std::decay_t<decltype(x)>,
                               Substring>) {
               return x.GetBaseObject();
             } else
 #endif
               return BaseObject{x.GetFirstSymbol()};
           },
       },
       u);
 }
 
 template <typename T> const Symbol *Designator<T>::GetLastSymbol() const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](SymbolRef symbol) { return &*symbol; },
           [](const Substring &sstring) { return sstring.GetLastSymbol(); },
           [](const auto &x) {
 #if !__clang__ && __GNUC__ == 7 && __GNUC_MINOR__ == 2
             if constexpr (std::is_same_v<std::decay_t<decltype(x)>,
                               Substring>) {
               return x.GetLastSymbol();

flang/lib/Parser/message.cpp

const char *MessageFormattedText::Convert(std::string &&s) {
   return conversions_.front().c_str();
 }
 
 const char *MessageFormattedText::Convert(CharBlock x) {
   return Convert(x.ToString());
 }
 
 std::string MessageExpectedText::ToString() const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](CharBlock cb) {
             return MessageFormattedText("expected '%s'"_err_en_US, cb)
                 .MoveString();
           },
           [](const SetOfChars &set) {
             SetOfChars expect{set};
             if (expect.Has('\n')) {
return common::visit(
                   .MoveString();
             }
           },
       },
       u_);
 }
 
 bool MessageExpectedText::Merge(const MessageExpectedText &that) {
-  return std::visit(common::visitors{
+  return common::visit(common::visitors{
                            [](SetOfChars &s1, const SetOfChars &s2) {
                              s1 = s1.Union(s2);
                              return true;
                            },
                            [](const auto &, const auto &) { return false; },
                        },
       u_, that.u_);
 }
 
 bool Message::SortBefore(const Message &that) const {
   // Messages from prescanning have ProvenanceRange values for their locations,
   // while messages from later phases have CharBlock values, since the
   // conversion of cooked source stream locations to provenances is not
   // free and needs to be deferred, and many messages created during parsing
   // are speculative.  Messages with ProvenanceRange locations are ordered
   // before others for sorting.
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](CharBlock cb1, CharBlock cb2) {
             return cb1.begin() < cb2.begin();
           },
           [](CharBlock, const ProvenanceRange &) { return false; },
           [](const ProvenanceRange &pr1, const ProvenanceRange &pr2) {
             return pr1.start() < pr2.start();
           },
           [](const ProvenanceRange &, CharBlock) { return true; },
       },
       location_, that.location_);
 }
 
 bool Message::IsFatal() const { return severity() == Severity::Error; }
 
 Severity Message::severity() const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const MessageExpectedText &) { return Severity::Error; },
           [](const MessageFixedText &x) { return x.severity(); },
           [](const MessageFormattedText &x) { return x.severity(); },
       },
       text_);
 }
 
 std::string Message::ToString() const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const MessageFixedText &t) {
             return t.text().NULTerminatedToString();
           },
           [](const MessageFormattedText &t) { return t.string(); },
           [](const MessageExpectedText &e) { return e.ToString(); },
       },
       text_);
 }
 
 void Message::ResolveProvenances(const AllCookedSources &allCooked) {
   if (CharBlock * cb{std::get_if<CharBlock>(&location_)}) {
     if (std::optional<ProvenanceRange> resolved{
             allCooked.GetProvenanceRange(*cb)}) {
       location_ = *resolved;
     }
   }
   if (Message * attachment{attachment_.get()}) {
     attachment->ResolveProvenances(allCooked);
   }
 }
 
 std::optional<ProvenanceRange> Message::GetProvenanceRange(
     const AllCookedSources &allCooked) const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](CharBlock cb) { return allCooked.GetProvenanceRange(cb); },
           [](const ProvenanceRange &pr) { return std::make_optional(pr); },
       },
       location_);
 }
 
 void Message::Emit(llvm::raw_ostream &o, const AllCookedSources &allCooked,
bool Message::operator==(const Message &that) const {
   }
   return true;
 }
 
 bool Message::Merge(const Message &that) {
   return AtSameLocation(that) &&
       (!that.attachment_.get() ||
           attachment_.get() == that.attachment_.get()) &&
-      std::visit(
+      common::visit(
           common::visitors{
               [](MessageExpectedText &e1, const MessageExpectedText &e2) {
                 return e1.Merge(e2);
               },
               [](const auto &, const auto &) { return false; },
           },
           text_, that.text_);
 }
Message &Message::Attach(Message *m) {
   return *this;
 }
 
 Message &Message::Attach(std::unique_ptr<Message> &&m) {
   return Attach(m.release());
 }
 
 bool Message::AtSameLocation(const Message &that) const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](CharBlock cb1, CharBlock cb2) {
             return cb1.begin() == cb2.begin();
           },
           [](const ProvenanceRange &pr1, const ProvenanceRange &pr2) {
             return pr1.start() == pr2.start();
           },
           [](const auto &, const auto &) { return false; },

flang/lib/Parser/parse-tree.cpp

 CommonStmt::CommonStmt(std::optional<Name> &&name,
     std::list<CommonBlockObject> &&objects, std::list<Block> &&others) {
   blocks.emplace_front(std::move(name), std::move(objects));
   blocks.splice(blocks.end(), std::move(others));
 }
 
 // R901 designator
 bool Designator::EndsInBareName() const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const DataRef &dr) {
             return std::holds_alternative<Name>(dr.u) ||
                 std::holds_alternative<common::Indirection<StructureComponent>>(
                     dr.u);
           },
           [](const Substring &) { return false; },
       },

 
 // Set source in any type of node that has it.
 template <typename T> T WithSource(CharBlock source, T &&x) {
   x.source = source;
   return std::move(x);
 }
 
 static Expr ActualArgToExpr(ActualArgSpec &arg) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](common::Indirection<Expr> &y) { return std::move(y.value()); },
           [&](common::Indirection<Variable> &y) {
-            return std::visit(
+            return common::visit(
                 common::visitors{
                     [&](common::Indirection<Designator> &z) {
                       return WithSource(
                           z.value().source, Expr{std::move(z.value())});
                     },
                     [&](common::Indirection<FunctionReference> &z) {
                       return WithSource(
                           z.value().v.source, Expr{std::move(z.value())});
                     },
                 },
                 y.value().u);
           },
           [&](auto &) -> Expr { common::die("unexpected type"); },
       },
       std::get<ActualArg>(arg.t).u);
 }
 
 Designator FunctionReference::ConvertToArrayElementRef() {
   std::list<Expr> args;
   for (auto &arg : std::get<std::list<ActualArgSpec>>(v.t)) {
     args.emplace_back(ActualArgToExpr(arg));
   }
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const Name &name) {
             return WithSource(
                 v.source, MakeArrayElementRef(name, std::move(args)));
           },
           [&](ProcComponentRef &pcr) {
             return WithSource(v.source,
                 MakeArrayElementRef(std::move(pcr.v.thing), std::move(args)));
Statement<ActionStmt> StmtFunctionStmt::ConvertToAssignment() {
   auto variable{Variable{common::Indirection{WithSource(
       source, MakeArrayElementRef(funcName, std::move(subscripts)))}}};
   return Statement{std::nullopt,
       ActionStmt{common::Indirection{
           AssignmentStmt{std::move(variable), std::move(funcExpr)}}}};
 }
 
 CharBlock Variable::GetSource() const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const common::Indirection<Designator> &des) {
             return des.value().source;
           },
           [&](const common::Indirection<parser::FunctionReference> &call) {
             return call.value().v.source;
           },
       },
       u);
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Name &x) {
   return os << x.ToString();
 }
 } // namespace Fortran::parser

flang/lib/Parser/provenance.cpp

void AllSources::EmitMessage(llvm::raw_ostream &o,
     const std::optional<ProvenanceRange> &range, const std::string &message,
     bool echoSourceLine) const {
   if (!range) {
     o << message << '\n';
     return;
   }
   CHECK(IsValid(*range));
   const Origin &origin{MapToOrigin(range->start())};
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const Inclusion &inc) {
             o << inc.source.path();
             std::size_t offset{origin.covers.MemberOffset(range->start())};
             SourcePosition pos{inc.source.FindOffsetLineAndColumn(offset)};
             o << ':' << pos.line << ':' << pos.column;
             o << ": " << message << '\n';
             if (echoSourceLine) {
common::visit(
           [&](const CompilerInsertion &) { o << message << '\n'; },
       },
       origin.u);
 }
 
 const SourceFile *AllSources::GetSourceFile(
     Provenance at, std::size_t *offset) const {
   const Origin &origin{MapToOrigin(at)};
-  return std::visit(common::visitors{
+  return common::visit(common::visitors{
                            [&](const Inclusion &inc) {
                              if (offset) {
                                *offset = origin.covers.MemberOffset(at);
                              }
                              return &inc.source;
                            },
                            [&](const Macro &) {
-                          return GetSourceFile(origin.replaces.start(), offset);
+                             return GetSourceFile(
+                                 origin.replaces.start(), offset);
                            },
                            [offset](const CompilerInsertion &) {
                              if (offset) {
                                *offset = 0;
                              }
                              return static_cast<const SourceFile *>(nullptr);
                            },
                        },
       origin.u);
 }
 
 const char *AllSources::GetSource(ProvenanceRange range) const {
   Provenance start{range.start()};
   const Origin &origin{MapToOrigin(start)};
   return origin.covers.Contains(range)
       ? &origin[origin.covers.MemberOffset(start)]
       : nullptr;
 }
 
 std::optional<SourcePosition> AllSources::GetSourcePosition(
     Provenance prov) const {
   const Origin &origin{MapToOrigin(prov)};
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const Inclusion &inc) -> std::optional<SourcePosition> {
             std::size_t offset{origin.covers.MemberOffset(prov)};
             return inc.source.FindOffsetLineAndColumn(offset);
           },
           [&](const Macro &) {
             return GetSourcePosition(origin.replaces.start());
           },
AllSources::Origin::Origin(ProvenanceRange r, const SourceFile &included,
     : u{Inclusion{included, isModule}}, covers{r}, replaces{from} {}
 AllSources::Origin::Origin(ProvenanceRange r, ProvenanceRange def,
     ProvenanceRange use, const std::string &expansion)
     : u{Macro{def, expansion}}, covers{r}, replaces{use} {}
 AllSources::Origin::Origin(ProvenanceRange r, const std::string &text)
     : u{CompilerInsertion{text}}, covers{r} {}
 
 const char &AllSources::Origin::operator[](std::size_t n) const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [n](const Inclusion &inc) -> const char & {
             return inc.source.content()[n];
           },
           [n](const Macro &mac) -> const char & { return mac.expansion[n]; },
           [n](const CompilerInsertion &ins) -> const char & {
             return ins.text[n];
           },

 llvm::raw_ostream &AllSources::Dump(llvm::raw_ostream &o) const {
   o << "AllSources range_ ";
   DumpRange(o, range_);
   o << '\n';
   for (const Origin &m : origin_) {
     o << "   ";
     DumpRange(o, m.covers);
     o << " -> ";
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const Inclusion &inc) {
                         if (inc.isModule) {
                           o << "module ";
                         }
                         o << "file " << inc.source.path();
                       },
                       [&](const Macro &mac) { o << "macro " << mac.expansion; },
                       [&](const CompilerInsertion &ins) {
                         o << "compiler '" << ins.text << '\'';
                         if (ins.text.length() == 1) {
                           int ch = ins.text[0];
                           o << "(0x";
                           o.write_hex(ch & 0xff) << ")";
                         }
                       },
                   },
         m.u);
     if (IsValid(m.replaces)) {
       o << " replaces ";
       DumpRange(o, m.replaces);
     }
     o << '\n';
   }
   return o;

flang/lib/Parser/tools.cpp

 
 const Name &GetLastName(const Name &x) { return x; }
 
 const Name &GetLastName(const StructureComponent &x) {
   return GetLastName(x.component);
 }
 
 const Name &GetLastName(const DataRef &x) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const Name &name) -> const Name & { return name; },
           [](const common::Indirection<StructureComponent> &sc)
               -> const Name & { return GetLastName(sc.value()); },
           [](const common::Indirection<ArrayElement> &sc) -> const Name & {
             return GetLastName(sc.value().base);
           },
           [](const common::Indirection<CoindexedNamedObject> &ci)
               -> const Name & { return GetLastName(ci.value().base); },
       },
       x.u);
 }
 
 const Name &GetLastName(const Substring &x) {
   return GetLastName(std::get<DataRef>(x.t));
 }
 
 const Name &GetLastName(const Designator &x) {
-  return std::visit(
+  return common::visit(
       [](const auto &y) -> const Name & { return GetLastName(y); }, x.u);
 }
 
 const Name &GetLastName(const ProcComponentRef &x) {
   return GetLastName(x.v.thing);
 }
 
 const Name &GetLastName(const ProcedureDesignator &x) {
-  return std::visit(
+  return common::visit(
       [](const auto &y) -> const Name & { return GetLastName(y); }, x.u);
 }
 
 const Name &GetLastName(const Call &x) {
   return GetLastName(std::get<ProcedureDesignator>(x.t));
 }
 
 const Name &GetLastName(const FunctionReference &x) { return GetLastName(x.v); }
 
 const Name &GetLastName(const Variable &x) {
-  return std::visit(
+  return common::visit(
       [](const auto &indirection) -> const Name & {
         return GetLastName(indirection.value());
       },
       x.u);
 }
 
 const Name &GetLastName(const AllocateObject &x) {
-  return std::visit(
+  return common::visit(
       [](const auto &y) -> const Name & { return GetLastName(y); }, x.u);
 }
 
 const Name &GetFirstName(const Name &x) { return x; }
 
 const Name &GetFirstName(const StructureComponent &x) {
   return GetFirstName(x.base);
 }
 
 const Name &GetFirstName(const DataRef &x) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const Name &name) -> const Name & { return name; },
           [](const common::Indirection<StructureComponent> &sc)
               -> const Name & { return GetFirstName(sc.value()); },
           [](const common::Indirection<ArrayElement> &sc) -> const Name & {
             return GetFirstName(sc.value().base);
           },
           [](const common::Indirection<CoindexedNamedObject> &ci)
               -> const Name & { return GetFirstName(ci.value().base); },
       },
       x.u);
 }
 
 const Name &GetFirstName(const Substring &x) {
   return GetFirstName(std::get<DataRef>(x.t));
 }
 
 const Name &GetFirstName(const Designator &x) {
-  return std::visit(
+  return common::visit(
       [](const auto &y) -> const Name & { return GetFirstName(y); }, x.u);
 }
 
 const Name &GetFirstName(const ProcComponentRef &x) {
   return GetFirstName(x.v.thing);
 }
 
 const Name &GetFirstName(const ProcedureDesignator &x) {
-  return std::visit(
+  return common::visit(
       [](const auto &y) -> const Name & { return GetFirstName(y); }, x.u);
 }
 
 const Name &GetFirstName(const Call &x) {
   return GetFirstName(std::get<ProcedureDesignator>(x.t));
 }
 
 const Name &GetFirstName(const FunctionReference &x) {
   return GetFirstName(x.v);
 }
 
 const Name &GetFirstName(const Variable &x) {
-  return std::visit(
+  return common::visit(
       [](const auto &indirect) -> const Name & {
         return GetFirstName(indirect.value());
       },
       x.u);
 }
 
 const CoindexedNamedObject *GetCoindexedNamedObject(const DataRef &base) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const Name &) -> const CoindexedNamedObject * { return nullptr; },
           [](const common::Indirection<CoindexedNamedObject> &x)
               -> const CoindexedNamedObject * { return &x.value(); },
           [](const auto &x) -> const CoindexedNamedObject * {
             return GetCoindexedNamedObject(x.value().base);
           },
       },
       base.u);
 }
 const CoindexedNamedObject *GetCoindexedNamedObject(
     const Designator &designator) {
-  return std::visit(common::visitors{
-                        [](const DataRef &x) -> const CoindexedNamedObject * {
-                          return GetCoindexedNamedObject(x);
-                        },
-                        [](const Substring &x) -> const CoindexedNamedObject * {
-                          return GetCoindexedNamedObject(
-                              std::get<DataRef>(x.t));
-                        },
-                    },
+  return common::visit(
+      common::visitors{
+            return GetCoindexedNamedObject(std::get<DataRef>(x.t));
       designator.u);
 }
 const CoindexedNamedObject *GetCoindexedNamedObject(const Variable &variable) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const common::Indirection<Designator> &designator)
               -> const CoindexedNamedObject * {
             return GetCoindexedNamedObject(designator.value());
           },
           [](const auto &) -> const CoindexedNamedObject * { return nullptr; },
       },
       variable.u);
 }
 const CoindexedNamedObject *GetCoindexedNamedObject(
     const AllocateObject &allocateObject) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const StructureComponent &x) -> const CoindexedNamedObject * {
             return GetCoindexedNamedObject(x.base);
           },
           [](const auto &) -> const CoindexedNamedObject * { return nullptr; },
       },
       allocateObject.u);
 }
 } // namespace Fortran::parser

flang/lib/Parser/unparse.cpp

public:
   void Before(const IntrinsicTypeSpec::Logical &) { Word("LOGICAL"); }
   void Post(const IntrinsicTypeSpec::DoubleComplex &) {
     Word("DOUBLE COMPLEX");
   }
   void Before(const IntegerTypeSpec &) { // R705
     Word("INTEGER");
   }
   void Unparse(const KindSelector &x) { // R706
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const ScalarIntConstantExpr &y) {
               Put('('), Word("KIND="), Walk(y), Put(')');
             },
             [&](const KindSelector::StarSize &y) { Put('*'), Walk(y.v); },
         },
         x.u);
   }
public:
   void Unparse(const ComplexLiteralConstant &x) { // R718 - R720
     Put('('), Walk(x.t, ","), Put(')');
   }
   void Unparse(const CharSelector::LengthAndKind &x) { // R721
     Put('('), Word("KIND="), Walk(x.kind);
     Walk(", LEN=", x.length), Put(')');
   }
   void Unparse(const LengthSelector &x) { // R722
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const TypeParamValue &y) {
                         Put('('), Word("LEN="), Walk(y), Put(')');
                       },
                       [&](const CharLength &y) { Put('*'), Walk(y); },
                   },
         x.u);
   }
   void Unparse(const CharLength &x) { // R723
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const TypeParamValue &y) { Put('('), Walk(y), Put(')'); },
             [&](const std::int64_t &y) { Walk(y); },
         },
         x.u);
   }
   void Unparse(const CharLiteralConstant &x) { // R724
     const auto &str{std::get<std::string>(x.t)};
void Unparse(const DataComponentDefStmt &x) { // R737
     const auto &dts{std::get<DeclarationTypeSpec>(x.t)};
     const auto &attrs{std::get<std::list<ComponentAttrSpec>>(x.t)};
     const auto &decls{std::get<std::list<ComponentOrFill>>(x.t)};
     Walk(dts), Walk(", ", attrs, ", ");
     if (!attrs.empty() ||
         (!std::holds_alternative<DeclarationTypeSpec::Record>(dts.u) &&
             std::none_of(
                 decls.begin(), decls.end(), [](const ComponentOrFill &c) {
-                  return std::visit(
+                  return common::visit(
                       common::visitors{
                           [](const ComponentDecl &d) {
                             const auto &init{
                                 std::get<std::optional<Initialization>>(d.t)};
                             return init &&
                                 std::holds_alternative<std::list<
                                     common::Indirection<DataStmtValue>>>(
                                     init->u);
                           },
                           [](const FillDecl &) { return false; },
                       },
                       c.u);
                 }))) {
       Put(" ::");
     }
     Put(' '), Walk(decls, ", ");
   }
   void Unparse(const Allocatable &) { // R738
     Word("ALLOCATABLE");
   }
   void Unparse(const Pointer &) { Word("POINTER"); }
   void Unparse(const Contiguous &) { Word("CONTIGUOUS"); }
   void Before(const ComponentAttrSpec &x) {
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const CoarraySpec &) { Word("CODIMENSION["); },
                       [&](const ComponentArraySpec &) { Word("DIMENSION("); },
                       [](const auto &) {},
                   },
         x.u);
   }
   void Post(const ComponentAttrSpec &x) {
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const CoarraySpec &) { Put(']'); },
                       [&](const ComponentArraySpec &) { Put(')'); },
                       [](const auto &) {},
                   },
         x.u);
   }
   void Unparse(const ComponentDecl &x) { // R739
     Walk(std::get<ObjectName>(x.t));
     Walk("(", std::get<std::optional<ComponentArraySpec>>(x.t), ")");
     Walk("[", std::get<std::optional<CoarraySpec>>(x.t), "]");
     Walk("*", std::get<std::optional<CharLength>>(x.t));
     Walk(std::get<std::optional<Initialization>>(x.t));
   }
   void Unparse(const FillDecl &x) { // DEC extension
     Put("%FILL");
     Walk("(", std::get<std::optional<ComponentArraySpec>>(x.t), ")");
     Walk("*", std::get<std::optional<CharLength>>(x.t));
   }
   void Unparse(const ComponentArraySpec &x) { // R740
-    std::visit(common::visitors{
-                   [&](const std::list<ExplicitShapeSpec> &y) { Walk(y, ","); },
-                   [&](const DeferredShapeSpecList &y) { Walk(y); },
-               },
+    common::visit(
+        common::visitors{
         x.u);
   }
   void Unparse(const ProcComponentDefStmt &x) { // R741
     Word("PROCEDURE(");
     Walk(std::get<std::optional<ProcInterface>>(x.t)), Put(')');
     Walk(", ", std::get<std::list<ProcComponentAttrSpec>>(x.t), ", ");
     Put(" :: "), Walk(std::get<std::list<ProcDecl>>(x.t), ", ");
   }
   void Unparse(const NoPass &) { // R742
     Word("NOPASS");
   }
   void Unparse(const Pass &x) { Word("PASS"), Walk("(", x.v, ")"); }
   void Unparse(const Initialization &x) { // R743 & R805
-    std::visit(common::visitors{
-                   [&](const ConstantExpr &y) { Put(" = "), Walk(y); },
-                   [&](const NullInit &y) { Put(" => "), Walk(y); },
-                   [&](const InitialDataTarget &y) { Put(" => "), Walk(y); },
-                   [&](const std::list<common::Indirection<DataStmtValue>> &y) {
-                     Walk("/", y, ", ", "/");
-                   },
-               },
+    common::visit(
+        common::visitors{
         x.u);
   }
   void Unparse(const PrivateStmt &) { // R745
     Word("PRIVATE");
   }
   void Unparse(const TypeBoundProcedureStmt::WithoutInterface &x) { // R749
     Word("PROCEDURE"), Walk(", ", x.attributes, ", ");
     Put(" :: "), Walk(x.declarations, ", ");
void Unparse(const TypeDeclarationStmt &x) { // R801
     }};
 
     if (useDoubledColons()) {
       Put(" ::");
     }
     Put(' '), Walk(std::get<std::list<EntityDecl>>(x.t), ", ");
   }
   void Before(const AttrSpec &x) { // R802
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const CoarraySpec &) { Word("CODIMENSION["); },
                       [&](const ArraySpec &) { Word("DIMENSION("); },
                       [](const auto &) {},
                   },
         x.u);
   }
   void Post(const AttrSpec &x) {
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const CoarraySpec &) { Put(']'); },
                       [&](const ArraySpec &) { Put(')'); },
                       [](const auto &) {},
                   },
         x.u);
   }
   void Unparse(const EntityDecl &x) { // R803
     Walk(std::get<ObjectName>(x.t));
     Walk("(", std::get<std::optional<ArraySpec>>(x.t), ")");
     Walk("[", std::get<std::optional<CoarraySpec>>(x.t), "]");
     Walk("*", std::get<std::optional<CharLength>>(x.t));
     Walk(std::get<std::optional<Initialization>>(x.t));
   }
   void Unparse(const NullInit &) { // R806
     Word("NULL()");
   }
   void Unparse(const LanguageBindingSpec &x) { // R808 & R1528
     Word("BIND(C"), Walk(", NAME=", x.v), Put(')');
   }
   void Unparse(const CoarraySpec &x) { // R809
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const DeferredCoshapeSpecList &y) { Walk(y); },
                       [&](const ExplicitCoshapeSpec &y) { Walk(y); },
                   },
         x.u);
   }
   void Unparse(const DeferredCoshapeSpecList &x) { // R810
     for (auto j{x.v}; j > 0; --j) {
       Put(':');
       if (j > 1) {
         Put(',');
       }
     }
   }
   void Unparse(const ExplicitCoshapeSpec &x) { // R811
     Walk(std::get<std::list<ExplicitShapeSpec>>(x.t), ",", ",");
     Walk(std::get<std::optional<SpecificationExpr>>(x.t), ":"), Put('*');
   }
   void Unparse(const ExplicitShapeSpec &x) { // R812 - R813 & R816 - R818
     Walk(std::get<std::optional<SpecificationExpr>>(x.t), ":");
     Walk(std::get<SpecificationExpr>(x.t));
   }
   void Unparse(const ArraySpec &x) { // R815
-    std::visit(common::visitors{
-                   [&](const std::list<ExplicitShapeSpec> &y) { Walk(y, ","); },
-                   [&](const std::list<AssumedShapeSpec> &y) { Walk(y, ","); },
-                   [&](const DeferredShapeSpecList &y) { Walk(y); },
-                   [&](const AssumedSizeSpec &y) { Walk(y); },
-                   [&](const ImpliedShapeSpec &y) { Walk(y); },
-                   [&](const AssumedRankSpec &y) { Walk(y); },
-               },
+    common::visit(
+        common::visitors{
         x.u);
   }
   void Post(const AssumedShapeSpec &) { Put(':'); } // R819
   void Unparse(const DeferredShapeSpecList &x) { // R820
     for (auto j{x.v}; j > 0; --j) {
       Put(':');
       if (j > 1) {
         Put(',');
public:
   void Unparse(const ValueStmt &x) { // R861
     Word("VALUE :: "), Walk(x.v, ", ");
   }
   void Unparse(const VolatileStmt &x) { // R862
     Word("VOLATILE :: "), Walk(x.v, ", ");
   }
   void Unparse(const ImplicitStmt &x) { // R863
     Word("IMPLICIT ");
-    std::visit(common::visitors{
-                   [&](const std::list<ImplicitSpec> &y) { Walk(y, ", "); },
-                   [&](const std::list<ImplicitStmt::ImplicitNoneNameSpec> &y) {
-                     Word("NONE"), Walk(" (", y, ", ", ")");
-                   },
-               },
+    common::visit(
+        common::visitors{
         x.u);
   }
   void Unparse(const ImplicitSpec &x) { // R864
     Walk(std::get<DeclarationTypeSpec>(x.t));
     Put('('), Walk(std::get<std::list<LetterSpec>>(x.t), ", "), Put(')');
   }
   void Unparse(const LetterSpec &x) { // R865
     Put(*std::get<const char *>(x.t));
public:
   }
   void Unparse(const AllocateStmt &x) { // R927
     Word("ALLOCATE(");
     Walk(std::get<std::optional<TypeSpec>>(x.t), "::");
     Walk(std::get<std::list<Allocation>>(x.t), ", ");
     Walk(", ", std::get<std::list<AllocOpt>>(x.t), ", "), Put(')');
   }
   void Before(const AllocOpt &x) { // R928, R931
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const AllocOpt::Mold &) { Word("MOLD="); },
                       [&](const AllocOpt::Source &) { Word("SOURCE="); },
                       [](const StatOrErrmsg &) {},
                   },
         x.u);
   }
   void Unparse(const Allocation &x) { // R932
     Walk(std::get<AllocateObject>(x.t));
     Walk("(", std::get<std::list<AllocateShapeSpec>>(x.t), ",", ")");
     Walk("[", std::get<std::optional<AllocateCoarraySpec>>(x.t), "]");
   }
   void Unparse(const AllocateShapeSpec &x) { // R934 & R938
     Walk(std::get<std::optional<BoundExpr>>(x.t), ":");
     Walk(std::get<BoundExpr>(x.t));
   }
   void Unparse(const AllocateCoarraySpec &x) { // R937
     Walk(std::get<std::list<AllocateCoshapeSpec>>(x.t), ",", ",");
     Walk(std::get<std::optional<BoundExpr>>(x.t), ":"), Put('*');
   }
   void Unparse(const NullifyStmt &x) { // R939
     Word("NULLIFY("), Walk(x.v, ", "), Put(')');
   }
   void Unparse(const DeallocateStmt &x) { // R941
     Word("DEALLOCATE(");
     Walk(std::get<std::list<AllocateObject>>(x.t), ", ");
     Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", "), Put(')');
   }
   void Before(const StatOrErrmsg &x) { // R942 & R1165
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const StatVariable &) { Word("STAT="); },
                       [&](const MsgVariable &) { Word("ERRMSG="); },
                   },
         x.u);
   }
 
   // R1001 - R1022
   void Unparse(const Expr::Parentheses &x) { Put('('), Walk(x.v), Put(')'); }
   void Before(const Expr::UnaryPlus &) { Put("+"); }
   void Before(const Expr::Negate &) { Put("-"); }
   void Before(const Expr::NOT &) { Word(".NOT."); }
public:
   }
   void Unparse(const PointerAssignmentStmt &x) { // R1033, R1034, R1038
     if (asFortran_ && x.typedAssignment.get()) {
       Put(' ');
       asFortran_->assignment(out_, *x.typedAssignment);
       Put('\n');
     } else {
       Walk(std::get<DataRef>(x.t));
-      std::visit(
+      common::visit(
           common::visitors{
               [&](const std::list<BoundsRemapping> &y) {
                 Put('('), Walk(y), Put(')');
               },
               [&](const std::list<BoundsSpec> &y) { Walk("(", y, ", ", ")"); },
           },
           std::get<PointerAssignmentStmt::Bounds>(x.t).u);
       Put(" => "), Walk(std::get<Expr>(x.t));
void Unparse(const LabelDoStmt &x) { // R1121
     Word("DO "), Walk(std::get<Label>(x.t));
     Walk(" ", std::get<std::optional<LoopControl>>(x.t));
   }
   void Unparse(const NonLabelDoStmt &x) { // R1122
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("DO "), Walk(std::get<std::optional<LoopControl>>(x.t));
   }
   void Unparse(const LoopControl &x) { // R1123
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const ScalarLogicalExpr &y) {
                         Word("WHILE ("), Walk(y), Put(')');
                       },
                       [&](const auto &y) { Walk(y); },
                   },
         x.u);
   }
   void Unparse(const ConcurrentHeader &x) { // R1125
     Put('('), Walk(std::get<std::optional<IntegerTypeSpec>>(x.t), "::");
     Walk(std::get<std::list<ConcurrentControl>>(x.t), ", ");
     Walk(", ", std::get<std::optional<ScalarLogicalExpr>>(x.t)), Put(')');
   }
   void Unparse(const ConcurrentControl &x) { // R1126 - R1128

   void Unparse(const CaseStmt &x) { // R1142
     Outdent(), Word("CASE "), Walk(std::get<CaseSelector>(x.t));
     Walk(" ", std::get<std::optional<Name>>(x.t)), Indent();
   }
   void Unparse(const EndSelectStmt &x) { // R1143 & R1151 & R1155
     Outdent(), Word("END SELECT"), Walk(" ", x.v);
   }
   void Unparse(const CaseSelector &x) { // R1145
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const std::list<CaseValueRange> &y) {
                         Put('('), Walk(y), Put(')');
                       },
                       [&](const Default &) { Word("DEFAULT"); },
                   },
         x.u);
   }
   void Unparse(const CaseValueRange::Range &x) { // R1146
     Walk(x.lower), Put(':'), Walk(x.upper);
   }
   void Unparse(const SelectRankStmt &x) { // R1149
     Walk(std::get<0>(x.t), ": ");
     Word("SELECT RANK ("), Walk(std::get<1>(x.t), " => ");
     Walk(std::get<Selector>(x.t)), Put(')'), Indent();
   }
   void Unparse(const SelectRankCaseStmt &x) { // R1150
     Outdent(), Word("RANK ");
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const ScalarIntConstantExpr &y) {
                         Put('('), Walk(y), Put(')');
                       },
                       [&](const Star &) { Put("(*)"); },
                       [&](const Default &) { Word("DEFAULT"); },
                   },
         std::get<SelectRankCaseStmt::Rank>(x.t).u);
     Walk(" ", std::get<std::optional<Name>>(x.t)), Indent();
   }
   void Unparse(const SelectTypeStmt &x) { // R1153
     Walk(std::get<0>(x.t), ": ");
     Word("SELECT TYPE ("), Walk(std::get<1>(x.t), " => ");
     Walk(std::get<Selector>(x.t)), Put(')'), Indent();
   }
   void Unparse(const TypeGuardStmt &x) { // R1154
     Outdent(), Walk(std::get<TypeGuardStmt::Guard>(x.t));
     Walk(" ", std::get<std::optional<Name>>(x.t)), Indent();
   }
   void Unparse(const TypeGuardStmt::Guard &x) {
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const TypeSpec &y) { Word("TYPE IS ("), Walk(y), Put(')'); },
             [&](const DerivedTypeSpec &y) {
               Word("CLASS IS ("), Walk(y), Put(')');
             },
             [&](const Default &) { Word("CLASS DEFAULT"); },
         },
         x.u);
void Unparse(const SyncTeamStmt &x) { // R1169
     Word("SYNC TEAM ("), Walk(std::get<TeamValue>(x.t));
     Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", "), Put(')');
   }
   void Unparse(const EventPostStmt &x) { // R1170
     Word("EVENT POST ("), Walk(std::get<EventVariable>(x.t));
     Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", "), Put(')');
   }
   void Before(const EventWaitStmt::EventWaitSpec &x) { // R1173, R1174
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const ScalarIntExpr &) { Word("UNTIL_COUNT="); },
                       [](const StatOrErrmsg &) {},
                   },
         x.u);
   }
   void Unparse(const EventWaitStmt &x) { // R1170
     Word("EVENT WAIT ("), Walk(std::get<EventVariable>(x.t));
     Walk(", ", std::get<std::list<EventWaitStmt::EventWaitSpec>>(x.t), ", ");
     Put(')');
   }
   void Unparse(const FormTeamStmt &x) { // R1175, R1177
     Word("FORM TEAM ("), Walk(std::get<ScalarIntExpr>(x.t));
     Put(','), Walk(std::get<TeamVariable>(x.t));
     Walk(", ", std::get<std::list<FormTeamStmt::FormTeamSpec>>(x.t), ", ");
     Put(')');
   }
   void Before(const FormTeamStmt::FormTeamSpec &x) { // R1176, R1178
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const ScalarIntExpr &) { Word("NEW_INDEX="); },
                       [](const StatOrErrmsg &) {},
                   },
         x.u);
   }
   void Unparse(const LockStmt &x) { // R1179
     Word("LOCK ("), Walk(std::get<LockVariable>(x.t));
     Walk(", ", std::get<std::list<LockStmt::LockStat>>(x.t), ", ");
     Put(')');
   }
   void Before(const LockStmt::LockStat &x) { // R1180
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const ScalarLogicalVariable &) { Word("ACQUIRED_LOCK="); },
             [](const StatOrErrmsg &) {},
         },
         x.u);
   }
   void Unparse(const UnlockStmt &x) { // R1181
     Word("UNLOCK ("), Walk(std::get<LockVariable>(x.t));
     Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", ");
     Put(')');
   }
 
   void Unparse(const OpenStmt &x) { // R1204
     Word("OPEN ("), Walk(x.v, ", "), Put(')');
   }
   bool Pre(const ConnectSpec &x) { // R1205
-    return std::visit(common::visitors{
+    return common::visit(common::visitors{
                              [&](const FileUnitNumber &) {
                                Word("UNIT=");
                                return true;
                              },
                              [&](const FileNameExpr &) {
                                Word("FILE=");
                                return true;
                              },
                              [&](const ConnectSpec::CharExpr &y) {
                                Walk(y.t, "=");
                                return false;
                              },
                              [&](const MsgVariable &) {
                                Word("IOMSG=");
                                return true;
                              },
                              [&](const StatVariable &) {
                                Word("IOSTAT=");
                                return true;
                              },
                              [&](const ConnectSpec::Recl &) {
                                Word("RECL=");
                                return true;
                              },
                              [&](const ConnectSpec::Newunit &) {
                                Word("NEWUNIT=");
                                return true;
                              },
                              [&](const ErrLabel &) {
                                Word("ERR=");
                                return true;
                              },
                              [&](const StatusExpr &) {
                                Word("STATUS=");
                                return true;
                              },
                          },
         x.u);
   }
   void Unparse(const CloseStmt &x) { // R1208
     Word("CLOSE ("), Walk(x.v, ", "), Put(')');
   }
   void Before(const CloseStmt::CloseSpec &x) { // R1209
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const FileUnitNumber &) { Word("UNIT="); },
                       [&](const StatVariable &) { Word("IOSTAT="); },
                       [&](const MsgVariable &) { Word("IOMSG="); },
                       [&](const ErrLabel &) { Word("ERR="); },
                       [&](const StatusExpr &) { Word("STATUS="); },
                   },
         x.u);
   }
   void Unparse(const ReadStmt &x) { // R1210
     Word("READ ");
     if (x.iounit) {
       Put('('), Walk(x.iounit);
       if (x.format) {
         Put(", "), Walk(x.format);
void Unparse(const WriteStmt &x) { // R1211
     }
     Put(')'), Walk(" ", x.items, ", ");
   }
   void Unparse(const PrintStmt &x) { // R1212
     Word("PRINT "), Walk(std::get<Format>(x.t));
     Walk(", ", std::get<std::list<OutputItem>>(x.t), ", ");
   }
   bool Pre(const IoControlSpec &x) { // R1213
-    return std::visit(common::visitors{
+    return common::visit(common::visitors{
                              [&](const IoUnit &) {
                                Word("UNIT=");
                                return true;
                              },
                              [&](const Format &) {
                                Word("FMT=");
                                return true;
                              },
                              [&](const Name &) {
                                Word("NML=");
                                return true;
                              },
                              [&](const IoControlSpec::CharExpr &y) {
                                Walk(y.t, "=");
                                return false;
                              },
                              [&](const IoControlSpec::Asynchronous &) {
                                Word("ASYNCHRONOUS=");
                                return true;
                              },
                              [&](const EndLabel &) {
                                Word("END=");
                                return true;
                              },
                              [&](const EorLabel &) {
                                Word("EOR=");
                                return true;
                              },
                              [&](const ErrLabel &) {
                                Word("ERR=");
                                return true;
                              },
                              [&](const IdVariable &) {
                                Word("ID=");
                                return true;
                              },
                              [&](const MsgVariable &) {
                                Word("IOMSG=");
                                return true;
                              },
                              [&](const StatVariable &) {
                                Word("IOSTAT=");
                                return true;
                              },
                              [&](const IoControlSpec::Pos &) {
                                Word("POS=");
                                return true;
                              },
                              [&](const IoControlSpec::Rec &) {
                                Word("REC=");
                                return true;
                              },
                              [&](const IoControlSpec::Size &) {
                                Word("SIZE=");
                                return true;
                              },
                          },
         x.u);
   }
   void Unparse(const InputImpliedDo &x) { // R1218
     Put('('), Walk(std::get<std::list<InputItem>>(x.t), ", "), Put(", ");
     Walk(std::get<IoImpliedDoControl>(x.t)), Put(')');
   }
   void Unparse(const OutputImpliedDo &x) { // R1219
     Put('('), Walk(std::get<std::list<OutputItem>>(x.t), ", "), Put(", ");
     Walk(std::get<IoImpliedDoControl>(x.t)), Put(')');
   }
   void Unparse(const WaitStmt &x) { // R1222
     Word("WAIT ("), Walk(x.v, ", "), Put(')');
   }
   void Before(const WaitSpec &x) { // R1223
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const FileUnitNumber &) { Word("UNIT="); },
                       [&](const EndLabel &) { Word("END="); },
                       [&](const EorLabel &) { Word("EOR="); },
                       [&](const ErrLabel &) { Word("ERR="); },
                       [&](const IdExpr &) { Word("ID="); },
                       [&](const MsgVariable &) { Word("IOMSG="); },
                       [&](const StatVariable &) { Word("IOSTAT="); },
                   },
         x.u);
   }
   void Unparse(const BackspaceStmt &x) { // R1224
     Word("BACKSPACE ("), Walk(x.v, ", "), Put(')');
   }
   void Unparse(const EndfileStmt &x) { // R1225
     Word("ENDFILE ("), Walk(x.v, ", "), Put(')');
   }
   void Unparse(const RewindStmt &x) { // R1226
     Word("REWIND ("), Walk(x.v, ", "), Put(')');
   }
   void Before(const PositionOrFlushSpec &x) { // R1227 & R1229
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const FileUnitNumber &) { Word("UNIT="); },
                       [&](const MsgVariable &) { Word("IOMSG="); },
                       [&](const StatVariable &) { Word("IOSTAT="); },
                       [&](const ErrLabel &) { Word("ERR="); },
                   },
         x.u);
   }
   void Unparse(const FlushStmt &x) { // R1228
     Word("FLUSH ("), Walk(x.v, ", "), Put(')');
   }
   void Unparse(const InquireStmt &x) { // R1230
     Word("INQUIRE (");
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const InquireStmt::Iolength &y) {
               Word("IOLENGTH="), Walk(y.t, ") ");
             },
             [&](const std::list<InquireSpec> &y) { Walk(y, ", "), Put(')'); },
         },
         x.u);
   }
   bool Pre(const InquireSpec &x) { // R1231
-    return std::visit(common::visitors{
+    return common::visit(common::visitors{
                              [&](const FileUnitNumber &) {
                                Word("UNIT=");
                                return true;
                              },
                              [&](const FileNameExpr &) {
                                Word("FILE=");
                                return true;
                              },
                              [&](const InquireSpec::CharVar &y) {
                                Walk(y.t, "=");
                                return false;
                              },
                              [&](const InquireSpec::IntVar &y) {
                                Walk(y.t, "=");
                                return false;
                              },
                              [&](const InquireSpec::LogVar &y) {
                                Walk(y.t, "=");
                                return false;
                              },
                              [&](const IdExpr &) {
                                Word("ID=");
                                return true;
                              },
                              [&](const ErrLabel &) {
                                Word("ERR=");
                                return true;
                              },
                          },
         x.u);
   }
 
   void Before(const FormatStmt &) { // R1301
     Word("FORMAT");
   }
   void Unparse(const format::FormatSpecification &x) { // R1302, R1303, R1305
     Put('('), Walk("", x.items, ",", x.unlimitedItems.empty() ? "" : ",");
     Walk("*(", x.unlimitedItems, ",", ")"), Put(')');
   }
   void Unparse(const format::FormatItem &x) { // R1304, R1306, R1321
     if (x.repeatCount) {
       Walk(*x.repeatCount);
     }
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const std::string &y) { PutNormalized(y); },
                       [&](const std::list<format::FormatItem> &y) {
                         Walk("(", y, ",", ")");
                       },
                       [&](const auto &y) { Walk(y); },
                   },
         x.u);
   }
   void Unparse(
       const format::IntrinsicTypeDataEditDesc &x) { // R1307(1/2) - R1311
     switch (x.kind) {
 #define FMT(x) \
   case format::IntrinsicTypeDataEditDesc::Kind::x: \
     Put(#x); \
#undef FMT
   void Before(const ModuleStmt &) { // R1405
     Word("MODULE "), Indent();
   }
   void Unparse(const EndModuleStmt &x) { // R1406
     EndSubprogram("MODULE", x.v);
   }
   void Unparse(const UseStmt &x) { // R1409
     Word("USE"), Walk(", ", x.nature), Put(" :: "), Walk(x.moduleName);
-    std::visit(common::visitors{
-                   [&](const std::list<Rename> &y) { Walk(", ", y, ", "); },
-                   [&](const std::list<Only> &y) { Walk(", ONLY: ", y, ", "); },
-               },
+    common::visit(
+        common::visitors{
         x.u);
   }
   void Unparse(const Rename &x) { // R1411
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const Rename::Names &y) { Walk(y.t, " => "); },
                       [&](const Rename::Operators &y) {
-                     Word("OPERATOR("), Walk(y.t, ") => OPERATOR("), Put(")");
+                        Word("OPERATOR("), Walk(y.t, ") => OPERATOR("),
+                            Put(")");
                       },
                   },
         x.u);
   }
   void Unparse(const SubmoduleStmt &x) { // R1417
     Word("SUBMODULE ("), WalkTupleElements(x.t, ")"), Indent();
   }
   void Unparse(const ParentIdentifier &x) { // R1418
     Walk(std::get<Name>(x.t)), Walk(":", std::get<std::optional<Name>>(x.t));
   }
   void Unparse(const EndSubmoduleStmt &x) { // R1419
     EndSubprogram("SUBMODULE", x.v);
   }
   void Unparse(const BlockDataStmt &x) { // R1421
     Word("BLOCK DATA"), Walk(" ", x.v), Indent();
   }
   void Unparse(const EndBlockDataStmt &x) { // R1422
     EndSubprogram("BLOCK DATA", x.v);
   }
 
   void Unparse(const InterfaceStmt &x) { // R1503
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const std::optional<GenericSpec> &y) {
                         Word("INTERFACE"), Walk(" ", y);
                       },
                       [&](const Abstract &) { Word("ABSTRACT INTERFACE"); },
                   },
         x.u);
     Indent();
   }
   void Unparse(const EndInterfaceStmt &x) { // R1504
     Outdent(), Word("END INTERFACE"), Walk(" ", x.v);
   }
   void Unparse(const ProcedureStmt &x) { // R1506
     if (std::get<ProcedureStmt::Kind>(x.t) ==
         ProcedureStmt::Kind::ModuleProcedure) {
       Word("MODULE ");
     }
     Word("PROCEDURE :: ");
     Walk(std::get<std::list<Name>>(x.t), ", ");
   }
   void Before(const GenericSpec &x) { // R1508, R1509
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const DefinedOperator &) { Word("OPERATOR("); },
             [&](const GenericSpec::Assignment &) { Word("ASSIGNMENT(=)"); },
             [&](const GenericSpec::ReadFormatted &) {
               Word("READ(FORMATTED)");
             },
             [&](const GenericSpec::ReadUnformatted &) {
               Word("READ(UNFORMATTED)");
             },
             [&](const GenericSpec::WriteFormatted &) {
               Word("WRITE(FORMATTED)");
             },
             [&](const GenericSpec::WriteUnformatted &) {
               Word("WRITE(UNFORMATTED)");
             },
             [](const auto &) {},
         },
         x.u);
   }
   void Post(const GenericSpec &x) {
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const DefinedOperator &) { Put(')'); },
                       [](const auto &) {},
                   },
         x.u);
   }
   void Unparse(const GenericStmt &x) { // R1510
     Word("GENERIC"), Walk(", ", std::get<std::optional<AccessSpec>>(x.t));
     Put(" :: "), Walk(std::get<GenericSpec>(x.t)), Put(" => ");
     Walk(std::get<std::list<Name>>(x.t), ", ");
   }
   void Unparse(const ExternalStmt &x) { // R1511
#undef FMT
   void Unparse(const StmtFunctionStmt &x) { // R1544
     Walk(std::get<Name>(x.t)), Put('(');
     Walk(std::get<std::list<Name>>(x.t), ", "), Put(") = ");
     Walk(std::get<Scalar<Expr>>(x.t));
   }
 
   // Directives, extensions, and deprecated constructs
   void Unparse(const CompilerDirective &x) {
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const std::list<CompilerDirective::IgnoreTKR> &tkr) {
               Word("!DIR$ IGNORE_TKR"); // emitted even if tkr list is empty
               Walk(" ", tkr, ", ");
             },
             [&](const std::list<CompilerDirective::NameValue> &names) {
               Walk("!DIR$ ", names, " ");
             },
#include "llvm/Frontend/OpenACC/ACC.inc"
   void Unparse(const AccObjectListWithModifier &x) {
     Walk(std::get<std::optional<AccDataModifier>>(x.t), ":");
     Walk(std::get<AccObjectList>(x.t));
   }
   void Unparse(const AccDataModifier::Modifier &x) {
     Word(AccDataModifier::EnumToString(x));
   }
   void Unparse(const AccBindClause &x) {
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const Name &y) { Put('('), Walk(y), Put(')'); },
                       [&](const ScalarDefaultCharExpr &y) {
                         Put('('), Walk(y), Put(')');
                       },
                   },
         x.u);
   }
   void Unparse(const AccDefaultClause &x) {
     switch (x.v) {
     case llvm::acc::DefaultValue::ACC_Default_none:
       Put("NONE");
       break;
     case llvm::acc::DefaultValue::ACC_Default_present:
void Unparse(const OpenACCRoutineConstruct &x) {
     BeginOpenACC();
     Word("!$ACC ROUTINE");
     Walk("(", std::get<std::optional<Name>>(x.t), ")");
     Walk(std::get<AccClauseList>(x.t));
     Put("\n");
     EndOpenACC();
   }
   void Unparse(const AccObject &x) {
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const Designator &y) { Walk(y); },
                       [&](const Name &y) { Put("/"), Walk(y), Put("/"); },
                   },
         x.u);
   }
   void Unparse(const AccObjectList &x) { Walk(x.v, ","); }
   void Unparse(const AccReductionOperator::Operator &x) {
     Word(AccReductionOperator::EnumToString(x));
   }
   void Unparse(const AccObjectListWithReduction &x) {
     Walk(std::get<AccReductionOperator>(x.t));
void Unparse(const OpenACCWaitConstruct &x) {
     Walk(std::get<AccClauseList>(x.t));
     Put(")");
     Put("\n");
     EndOpenACC();
   }
 
   // OpenMP Clauses & Directives
   void Unparse(const OmpObject &x) {
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const Designator &y) { Walk(y); },
                       [&](const Name &y) { Put("/"), Walk(y), Put("/"); },
                   },
         x.u);
   }
   void Unparse(const OmpMapType::Always &) { Word("ALWAYS,"); }
   void Unparse(const OmpMapClause &x) {
     Walk(std::get<std::optional<OmpMapType>>(x.t), ":");
     Walk(std::get<OmpObjectList>(x.t));
   }
   void Unparse(const OmpScheduleModifier &x) {
#include "llvm/Frontend/OpenACC/ACC.inc"
   void Unparse(const OmpDependClause::InOut &x) {
     Put("(");
     Walk(std::get<OmpDependenceType>(x.t));
     Put(":");
     Walk(std::get<std::list<Designator>>(x.t), ",");
     Put(")");
   }
   bool Pre(const OmpDependClause &x) {
-    return std::visit(common::visitors{
-                          [&](const OmpDependClause::Source &) {
-                            Word("SOURCE");
-                            return false;
-                          },
-                          [&](const OmpDependClause::Sink &y) {
-                            Word("SINK:");
-                            Walk(y.v);
-                            Put(")");
-                            return false;
-                          },
-                          [&](const OmpDependClause::InOut &) { return true; },
-                      },
+    return common::visit(
+        common::visitors{
         x.u);
   }
   void Unparse(const OmpDefaultmapClause &x) {
     Walk(std::get<OmpDefaultmapClause::ImplicitBehavior>(x.t));
     Walk(":",
         std::get<std::optional<OmpDefaultmapClause::VariableCategory>>(x.t));
   }
 #define GEN_FLANG_CLAUSE_UNPARSE
void Unparse(const OpenMPDeclareReductionConstruct &x) {
     Walk(std::get<std::list<DeclarationTypeSpec>>(x.t), ","), Put(" : ");
     Walk(std::get<OmpReductionCombiner>(x.t));
     Put(")");
     Walk(std::get<std::optional<OmpReductionInitializerClause>>(x.t));
   }
   bool Pre(const OpenMPDeclarativeConstruct &x) {
     BeginOpenMP();
     Word("!$OMP ");
-    return std::visit(common::visitors{
-                          [&](const OpenMPDeclarativeAllocate &z) {
-                            Word("ALLOCATE (");
-                            Walk(std::get<OmpObjectList>(z.t));
-                            Put(")");
-                            Walk(std::get<OmpClauseList>(z.t));
-                            Put("\n");
-                            EndOpenMP();
-                            return false;
-                          },
-                          [&](const OpenMPDeclareReductionConstruct &) {
-                            Word("DECLARE REDUCTION ");
-                            return true;
-                          },
-                          [&](const OpenMPDeclareSimdConstruct &y) {
-                            Word("DECLARE SIMD ");
-                            Walk("(", std::get<std::optional<Name>>(y.t), ")");
-                            Walk(std::get<OmpClauseList>(y.t));
-                            Put("\n");
-                            EndOpenMP();
-                            return false;
-                          },
-                          [&](const OpenMPDeclareTargetConstruct &) {
-                            Word("DECLARE TARGET ");
-                            return true;
-                          },
-                          [&](const OpenMPThreadprivate &) {
-                            Word("THREADPRIVATE (");
-                            return true;
-                          },
-                      },
+    return common::visit(
+        common::visitors{
         x.u);
   }
   void Post(const OpenMPDeclarativeConstruct &) {
     Put("\n");
     EndOpenMP();
   }
   void Post(const OpenMPThreadprivate &) {
     Put(")\n");
void Unparse(const OpenMPCancelConstruct &x) {
     Word("!$OMP CANCEL ");
     Walk(std::get<OmpCancelType>(x.t));
     Walk(std::get<std::optional<OpenMPCancelConstruct::If>>(x.t));
     Put("\n");
     EndOpenMP();
   }
   void Unparse(const OmpMemoryOrderClause &x) { Walk(x.v); }
   void Unparse(const OmpAtomicClause &x) {
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const OmpMemoryOrderClause &y) { Walk(y); },
                       [&](const OmpClause &z) { Walk(z); },
                   },
         x.u);
   }
   void Unparse(const OpenMPFlushConstruct &x) {
     BeginOpenMP();
     Word("!$OMP FLUSH ");
     Walk(std::get<std::optional<std::list<OmpMemoryOrderClause>>>(x.t));
     Walk(" (", std::get<std::optional<OmpObjectList>>(x.t), ")");
     Put("\n");

flang/lib/Semantics/canonicalize-do.cpp

 
 public:
   template <typename T> bool Pre(T &) { return true; }
   template <typename T> void Post(T &) {}
   void Post(Block &block) {
     std::vector<LabelInfo> stack;
     for (auto i{block.begin()}, end{block.end()}; i != end; ++i) {
       if (auto *executableConstruct{std::get_if<ExecutableConstruct>(&i->u)}) {
-        std::visit(
+        common::visit(
             common::visitors{
                 [](auto &) {},
                 // Labels on end-stmt of constructs are accepted by f18 as an
                 // extension.
                 [&](common::Indirection<AssociateConstruct> &associate) {
                   CanonicalizeIfMatch(block, stack, i,
                       std::get<Statement<EndAssociateStmt>>(
                           associate.value().t));

flang/lib/Semantics/check-allocate.cpp

if (const DerivedTypeSpec * derived{info.typeSpec->AsDerived()}) {
                 info.typeSpec->AsFortran(), it.BuildResultDesignatorName());
       }
     }
   }
 
   const parser::Expr *parserSourceExpr{nullptr};
   for (const parser::AllocOpt &allocOpt :
       std::get<std::list<parser::AllocOpt>>(allocateStmt.t)) {
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const parser::StatOrErrmsg &statOrErr) {
-              std::visit(
+              common::visit(
                   common::visitors{
                       [&](const parser::StatVariable &) {
                         if (info.gotStat) { // C943
                           context.Say(
                               "STAT may not be duplicated in a ALLOCATE statement"_err_en_US);
                         }
                         info.gotStat = true;
                       },

flang/lib/Semantics/check-call.cpp

static void CheckExplicitInterfaceArg(evaluate::ActualArgument &arg,
     bool allowIntegerConversions) {
   auto &messages{context.messages()};
   std::string dummyName{"dummy argument"};
   if (!dummy.name.empty()) {
     dummyName += " '"s + parser::ToLowerCaseLetters(dummy.name) + "='";
   }
   auto restorer{
       messages.SetLocation(arg.sourceLocation().value_or(messages.at()))};
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const characteristics::DummyDataObject &object) {
             ConvertBOZLiteralArg(arg, object.type.type());
             if (auto *expr{arg.UnwrapExpr()}) {
               if (auto type{characteristics::TypeAndShape::Characterize(
                       *expr, context)}) {
                 arg.set_dummyIntent(object.intent);
                 bool isElemental{object.type.Rank() == 0 && proc.IsElemental()};

flang/lib/Semantics/check-case.cpp

 
 private:
   using Value = evaluate::Scalar<T>;
 
   void AddCase(const parser::CaseConstruct::Case &c) {
     const auto &stmt{std::get<parser::Statement<parser::CaseStmt>>(c.t)};
     const parser::CaseStmt &caseStmt{stmt.statement};
     const auto &selector{std::get<parser::CaseSelector>(caseStmt.t)};
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const std::list<parser::CaseValueRange> &ranges) {
               for (const auto &range : ranges) {
                 auto pair{ComputeBounds(range)};
                 if (pair.first && pair.second && *pair.first > *pair.second) {
                   context_.Say(stmt.source,
                       "CASE has lower bound greater than upper bound"_warn_en_US);
                 } else {
if (x && x->v) { // C1147
       }
       hasErrors_ = true;
     }
     return std::nullopt;
   }
 
   using PairOfValues = std::pair<std::optional<Value>, std::optional<Value>>;
   PairOfValues ComputeBounds(const parser::CaseValueRange &range) {
-    return std::visit(common::visitors{
-                          [&](const parser::CaseValue &x) {
-                            auto value{GetValue(x)};
-                            return PairOfValues{value, value};
-                          },
-                          [&](const parser::CaseValueRange::Range &x) {
-                            std::optional<Value> lo, hi;
-                            if (x.lower) {
-                              lo = GetValue(*x.lower);
-                            }
-                            if (x.upper) {
-                              hi = GetValue(*x.upper);
-                            }
-                            if ((x.lower && !lo) || (x.upper && !hi)) {
-                              return PairOfValues{}; // error case
-                            }
-                            return PairOfValues{std::move(lo), std::move(hi)};
-                          },
-                      },
+    return common::visit(
+        common::visitors{
         range.u);
   }
 
   struct Case {
     explicit Case(const parser::Statement<parser::CaseStmt> &s) : stmt{s} {}
     bool IsDefault() const { return !lower && !upper; }
     std::string AsFortran() const {
       std::string result;

flang/lib/Semantics/check-data.cpp

public:
   bool operator()(const evaluate::CoarrayRef &) { // C874
     context_.Say(
         source_, "Data object must not be a coindexed variable"_err_en_US);
     return false;
   }
   bool operator()(const evaluate::Subscript &subs) {
     DataVarChecker subscriptChecker{context_, source_};
     subscriptChecker.RestrictPointer();
-    return std::visit(
+    return common::visit(
                common::visitors{
                    [&](const evaluate::IndirectSubscriptIntegerExpr &expr) {
                      return CheckSubscriptExpr(expr);
                    },
                    [&](const evaluate::Triplet &triplet) {
                      return CheckSubscriptExpr(triplet.lower()) &&
                          CheckSubscriptExpr(triplet.upper()) &&
                          CheckSubscriptExpr(triplet.stride());
if (MaybeExpr expr{exprAnalyzer_.Analyze(*designator)}) {
         }
       }
     }
     currentSetHasFatalErrors_ = true;
   }
 }
 
 void DataChecker::Leave(const parser::DataStmtObject &dataObject) {
-  std::visit(common::visitors{
-                 [](const parser::DataImpliedDo &) { // has own Enter()/Leave()
-                 },
-                 [&](const auto &var) {
-                   auto expr{exprAnalyzer_.Analyze(var)};
-                   if (!expr ||
-                       !DataVarChecker{exprAnalyzer_.context(),
-                           parser::FindSourceLocation(dataObject)}(*expr)) {
-                     currentSetHasFatalErrors_ = true;
-                   }
-                 },
-             },
+  common::visit(
+      common::visitors{
       dataObject.u);
 }
 
 void DataChecker::Leave(const parser::DataStmtSet &set) {
   if (!currentSetHasFatalErrors_) {
     AccumulateDataInitializations(inits_, exprAnalyzer_, set);
   }
   currentSetHasFatalErrors_ = false;

flang/lib/Semantics/check-deallocate.cpp

 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/tools.h"
 
 namespace Fortran::semantics {
 
 void DeallocateChecker::Leave(const parser::DeallocateStmt &deallocateStmt) {
   for (const parser::AllocateObject &allocateObject :
       std::get<std::list<parser::AllocateObject>>(deallocateStmt.t)) {
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const parser::Name &name) {
               auto const *symbol{name.symbol};
               if (context_.HasError(symbol)) {
                 // already reported an error
               } else if (!IsVariableName(*symbol)) {
                 context_.Say(name.source,
                     "name in DEALLOCATE statement must be a variable name"_err_en_US);
common::visit(
               }
             },
         },
         allocateObject.u);
   }
   bool gotStat{false}, gotMsg{false};
   for (const parser::StatOrErrmsg &deallocOpt :
       std::get<std::list<parser::StatOrErrmsg>>(deallocateStmt.t)) {
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const parser::StatVariable &) {
               if (gotStat) {
                 context_.Say(
                     "STAT may not be duplicated in a DEALLOCATE statement"_err_en_US);
               }
               gotStat = true;
             },

flang/lib/Semantics/check-declarations.cpp

void CheckHelper::Check(const Symbol &symbol) {
   if (context_.HasError(symbol)) {
     return;
   }
   auto restorer{messages_.SetLocation(symbol.name())};
   context_.set_location(symbol.name());
   const DeclTypeSpec *type{symbol.GetType()};
   const DerivedTypeSpec *derived{type ? type->AsDerived() : nullptr};
   bool isDone{false};
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const UseDetails &x) { isDone = true; },
           [&](const HostAssocDetails &x) {
             CheckHostAssoc(symbol, x);
             isDone = true;
           },
           [&](const ProcBindingDetails &x) {
             CheckProcBinding(symbol, x);
if (details.implicitOrSpecExprError) {
           "No explicit type declared for '%s'"_err_en_US, symbol.name());
     }
   }
 }
 
 void CheckHelper::CheckGeneric(
     const Symbol &symbol, const GenericDetails &details) {
   CheckSpecificsAreDistinguishable(symbol, details);
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [&](const GenericKind::DefinedIo &io) {
                       CheckDefinedIoProc(symbol, details, io);
                     },
                     [](const auto &) {},
                 },
       details.kind().u);
 }
 
 // Check that the specifics of this generic are distinguishable from each other
 void CheckHelper::CheckSpecificsAreDistinguishable(
     const Symbol &generic, const GenericDetails &details) {
   GenericKind kind{details.kind()};
   const SymbolVector &specifics{details.specificProcs()};

 static bool ConflictsWithIntrinsicOperator(
     const GenericKind &kind, const Procedure &proc) {
   if (!kind.IsIntrinsicOperator()) {
     return false;
   }
   auto arg0{std::get<DummyDataObject>(proc.dummyArguments[0].u).type};
   auto type0{arg0.type()};
   if (proc.dummyArguments.size() == 1) { // unary
-    return std::visit(
+    return common::visit(
         common::visitors{
             [&](common::NumericOperator) { return IsIntrinsicNumeric(type0); },
             [&](common::LogicalOperator) { return IsIntrinsicLogical(type0); },
             [](const auto &) -> bool { DIE("bad generic kind"); },
         },
         kind.u);
   } else { // binary
     int rank0{arg0.Rank()};
     auto arg1{std::get<DummyDataObject>(proc.dummyArguments[1].u).type};
     auto type1{arg1.type()};
     int rank1{arg1.Rank()};
-    return std::visit(
+    return common::visit(
         common::visitors{
             [&](common::NumericOperator) {
               return IsIntrinsicNumeric(type0, rank0, type1, rank1);
             },
             [&](common::LogicalOperator) {
               return IsIntrinsicLogical(type0, rank0, type1, rank1);
             },
             [&](common::RelationalOperator opr) {

 // If the number of arguments is wrong for this intrinsic operator, return
 // false and return the error message in msg.
 std::optional<parser::MessageFixedText> CheckHelper::CheckNumberOfArgs(
     const GenericKind &kind, std::size_t nargs) {
   if (!kind.IsIntrinsicOperator()) {
     return std::nullopt;
   }
   std::size_t min{2}, max{2}; // allowed number of args; default is binary
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [&](const common::NumericOperator &x) {
                       if (x == common::NumericOperator::Add ||
                           x == common::NumericOperator::Subtract) {
                         min = 1; // + and - are unary or binary
                       }
                     },
                     [&](const common::LogicalOperator &x) {
                       if (x == common::LogicalOperator::Not) {
                         min = 1; // .NOT. is unary
                         max = 1;
                       }
                     },
                     [](const common::RelationalOperator &) {
                       // all are binary
                     },
                     [](const GenericKind::OtherKind &x) {
                       CHECK(x == GenericKind::OtherKind::Concat);
                     },
                     [](const auto &) { DIE("expected intrinsic operator"); },
                 },
       kind.u);
   if (nargs >= min && nargs <= max) {
     return std::nullopt;
   } else if (max == 1) {
     return "%s function '%s' must have one dummy argument"_err_en_US;
   } else if (min == 2) {
     return "%s function '%s' must have two dummy arguments"_err_en_US;
   } else {
if (arg1 && !arg2) {
       }
     }
   }
 }
 
 void SubprogramMatchHelper::CheckDummyArg(const Symbol &symbol1,
     const Symbol &symbol2, const DummyArgument &arg1,
     const DummyArgument &arg2) {
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                  [&](const DummyDataObject &obj1, const DummyDataObject &obj2) {
                    CheckDummyDataObject(symbol1, symbol2, obj1, obj2);
                  },
                  [&](const DummyProcedure &proc1, const DummyProcedure &proc2) {
                    CheckDummyProcedure(symbol1, symbol2, proc1, proc2);
                  },
                  [&](const DummyDataObject &, const auto &) {
                    Say(symbol1, symbol2,

flang/lib/Semantics/check-do-forall.cpp

public:
   void Check(const parser::ForallStmt &stmt) {
     CheckConcurrentHeader(GetConcurrentHeader(stmt));
   }
   void Check(const parser::ForallConstruct &construct) {
     CheckConcurrentHeader(GetConcurrentHeader(construct));
   }
 
   void Check(const parser::ForallAssignmentStmt &stmt) {
-    const evaluate::Assignment *assignment{std::visit(
+    const evaluate::Assignment *assignment{common::visit(
         common::visitors{[&](const auto &x) { return GetAssignment(x); }},
         stmt.u)};
     if (assignment) {
       CheckForallIndexesUsed(*assignment);
       CheckForImpureCall(assignment->lhs);
       CheckForImpureCall(assignment->rhs);
       if (const auto *proc{
               std::get_if<evaluate::ProcedureRef>(&assignment->u)}) {
         CheckForImpureCall(*proc);
       }
-      std::visit(common::visitors{
-                     [](const evaluate::Assignment::Intrinsic &) {},
-                     [&](const evaluate::ProcedureRef &proc) {
-                       CheckForImpureCall(proc);
-                     },
-                     [&](const evaluate::Assignment::BoundsSpec &bounds) {
-                       for (const auto &bound : bounds) {
-                         CheckForImpureCall(SomeExpr{bound});
-                       }
-                     },
-                     [&](const evaluate::Assignment::BoundsRemapping &bounds) {
-                       for (const auto &bound : bounds) {
-                         CheckForImpureCall(SomeExpr{bound.first});
-                         CheckForImpureCall(SomeExpr{bound.second});
-                       }
-                     },
-                 },
+      common::visit(
+          common::visitors{
           assignment->u);
     }
   }
 
 private:
   void SayBadDoControl(parser::CharBlock sourceLocation) {
     context_.Say(sourceLocation, "DO controls should be INTEGER"_err_en_US);
   }
template <typename T> void CheckForImpureCall(const T &x) {
     }
   }
 
   // Each index should be used on the LHS of each assignment in a FORALL
   void CheckForallIndexesUsed(const evaluate::Assignment &assignment) {
     SymbolVector indexVars{context_.GetIndexVars(IndexVarKind::FORALL)};
     if (!indexVars.empty()) {
       UnorderedSymbolSet symbols{evaluate::CollectSymbols(assignment.lhs)};
-      std::visit(
+      common::visit(
           common::visitors{
               [&](const evaluate::Assignment::BoundsSpec &spec) {
                 for (const auto &bound : spec) {
 // TODO: this is working around missing std::set::merge in some versions of
 // clang that we are building with
 #ifdef __clang__
                   auto boundSymbols{evaluate::CollectSymbols(bound)};
                   symbols.insert(boundSymbols.begin(), boundSymbols.end());

 }
 
 template <typename A>
 static parser::CharBlock GetConstructPosition(const A &a) {
   return std::get<0>(a.t).source;
 }
 
 static parser::CharBlock GetNodePosition(const ConstructNode &construct) {
-  return std::visit(
+  return common::visit(
       [&](const auto &x) { return GetConstructPosition(*x); }, construct);
 }
 
 void DoForallChecker::SayBadLeave(StmtType stmtType,
     const char *enclosingStmtName, const ConstructNode &construct) const {
   context_
       .Say("%s must not leave a %s statement"_err_en_US, EnumToString(stmtType),
           enclosingStmtName)
static bool ConstructIsDoConcurrent(const ConstructNode &construct) {
   const parser::DoConstruct *doConstruct{MaybeGetDoConstruct(construct)};
   return doConstruct && doConstruct->IsDoConcurrent();
 }
 
 // Check that CYCLE and EXIT statements do not cause flow of control to
 // leave DO CONCURRENT, CRITICAL, or CHANGE TEAM constructs.
 void DoForallChecker::CheckForBadLeave(
     StmtType stmtType, const ConstructNode &construct) const {
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [&](const parser::DoConstruct *doConstructPtr) {
                       if (doConstructPtr->IsDoConcurrent()) {
-                     // C1135 and C1167 -- CYCLE and EXIT statements can't leave
-                     // a DO CONCURRENT
+                        // C1135 and C1167 -- CYCLE and EXIT statements can't
+                        // leave a DO CONCURRENT
                         SayBadLeave(stmtType, "DO CONCURRENT", construct);
                       }
                     },
                     [&](const parser::CriticalConstruct *) {
                       // C1135 and C1168 -- similarly, for CRITICAL
                       SayBadLeave(stmtType, "CRITICAL", construct);
                     },
                     [&](const parser::ChangeTeamConstruct *) {
                       // C1135 and C1168 -- similarly, for CHANGE TEAM
                       SayBadLeave(stmtType, "CHANGE TEAM", construct);
                     },
                     [](const auto *) {},
                 },
       construct);
 }
 
 static bool StmtMatchesConstruct(const parser::Name *stmtName,
     StmtType stmtType, const std::optional<parser::Name> &constructName,
     const ConstructNode &construct) {
   bool inDoConstruct{MaybeGetDoConstruct(construct) != nullptr};
   if (!stmtName) {

flang/lib/Semantics/check-io.cpp

 void IoChecker::Enter(const parser::FileUnitNumber &) {
   SetSpecifier(IoSpecKind::Unit);
   flags_.set(Flag::NumberUnit);
 }
 
 void IoChecker::Enter(const parser::Format &spec) {
   SetSpecifier(IoSpecKind::Fmt);
   flags_.set(Flag::FmtOrNml);
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const parser::Label &) { flags_.set(Flag::LabelFmt); },
           [&](const parser::Star &) { flags_.set(Flag::StarFmt); },
           [&](const parser::Expr &format) {
             const SomeExpr *expr{GetExpr(format)};
             if (!expr) {
               return;
             }

flang/lib/Semantics/check-nullify.cpp

 
 void NullifyChecker::Leave(const parser::NullifyStmt &nullifyStmt) {
   CHECK(context_.location());
   const Scope &scope{context_.FindScope(*context_.location())};
   const Scope *pure{FindPureProcedureContaining(scope)};
   parser::ContextualMessages messages{
       *context_.location(), &context_.messages()};
   for (const parser::PointerObject &pointerObject : nullifyStmt.v) {
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const parser::Name &name) {
               const Symbol *symbol{name.symbol};
               if (context_.HasError(symbol)) {
                 // already reported an error
               } else if (!IsVariableName(*symbol) && !IsProcName(*symbol)) {
                 messages.Say(name.source,
                     "name in NULLIFY statement must be a variable or procedure pointer name"_err_en_US);

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

if (const auto *symbol{name.symbol}) {
     }
   }
 }
 
 void OmpStructureChecker::CheckPredefinedAllocatorRestriction(
     const parser::CharBlock &source,
     const parser::OmpObjectList &ompObjectList) {
   for (const auto &ompObject : ompObjectList.v) {
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const parser::Designator &designator) {
               if (const auto *dataRef{
                       std::get_if<parser::DataRef>(&designator.u)}) {
                 if (const auto *name{std::get_if<parser::Name>(&dataRef->u)}) {
                   CheckPredefinedAllocatorRestriction(source, *name);
                 }
               }
void OmpStructureChecker::CheckSIMDNest(const parser::OpenMPConstruct &c) {
   // supported.
 
   // Check if the parent context has the SIMD clause
   // Please note that we use GetContext() instead of GetContextParent()
   // because PushContextAndClauseSets() has not been called on the
   // current context yet.
   // TODO: Check for declare simd regions.
   bool eligibleSIMD{false};
-  std::visit(Fortran::common::visitors{
+  common::visit(Fortran::common::visitors{
                     // Allow `!$OMP ORDERED SIMD`
                     [&](const parser::OpenMPBlockConstruct &c) {
                       const auto &beginBlockDir{
                           std::get<parser::OmpBeginBlockDirective>(c.t)};
                       const auto &beginDir{
                           std::get<parser::OmpBlockDirective>(beginBlockDir.t)};
                       if (beginDir.v == llvm::omp::Directive::OMPD_ordered) {
                         const auto &clauses{
                             std::get<parser::OmpClauseList>(beginBlockDir.t)};
                         for (const auto &clause : clauses.v) {
                           if (std::get_if<parser::OmpClause::Simd>(&clause.u)) {
                             eligibleSIMD = true;
                             break;
                           }
                         }
                       }
                     },
                     [&](const parser::OpenMPSimpleStandaloneConstruct &c) {
                       const auto &dir{
                           std::get<parser::OmpSimpleStandaloneDirective>(c.t)};
                       if (dir.v == llvm::omp::Directive::OMPD_ordered) {
-                     const auto &clauses{std::get<parser::OmpClauseList>(c.t)};
+                        const auto &clauses{
+                            std::get<parser::OmpClauseList>(c.t)};
                         for (const auto &clause : clauses.v) {
                           if (std::get_if<parser::OmpClause::Simd>(&clause.u)) {
                             eligibleSIMD = true;
                             break;
                           }
                         }
                       }
                     },
                     // Allowing SIMD construct
                     [&](const parser::OpenMPLoopConstruct &c) {
                       const auto &beginLoopDir{
                           std::get<parser::OmpBeginLoopDirective>(c.t)};
                       const auto &beginDir{
                           std::get<parser::OmpLoopDirective>(beginLoopDir.t)};
                       if ((beginDir.v == llvm::omp::Directive::OMPD_simd) ||
                           (beginDir.v == llvm::omp::Directive::OMPD_do_simd)) {
                         eligibleSIMD = true;
                       }
                     },
                     [&](const parser::OpenMPAtomicConstruct &c) {
                       // Allow `!$OMP ATOMIC`
                       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);
   }
 }
 
 void OmpStructureChecker::CheckTargetNest(const parser::OpenMPConstruct &c) {
   // 2.12.5 Target Construct Restriction
   bool eligibleTarget{true};
   llvm::omp::Directive ineligibleTargetDir;
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const parser::OpenMPBlockConstruct &c) {
             const auto &beginBlockDir{
                 std::get<parser::OmpBeginBlockDirective>(c.t)};
             const auto &beginDir{
                 std::get<parser::OmpBlockDirective>(beginBlockDir.t)};
             if (beginDir.v == llvm::omp::Directive::OMPD_target_data) {
               eligibleTarget = false;
               ineligibleTargetDir = beginDir.v;
             }
           },
           [&](const parser::OpenMPStandaloneConstruct &c) {
-            std::visit(
+            common::visit(
                 common::visitors{
                     [&](const parser::OpenMPSimpleStandaloneConstruct &c) {
                       const auto &dir{
                           std::get<parser::OmpSimpleStandaloneDirective>(c.t)};
                       if (dir.v == llvm::omp::Directive::OMPD_target_update ||
                           dir.v ==
                               llvm::omp::Directive::OMPD_target_enter_data ||
                           dir.v ==
void OmpStructureChecker::Leave(const parser::OmpEndSectionsDirective &x) {
   if (GetContext().directive == llvm::omp::Directive::OMPD_end_sections) {
     dirContext_.pop_back();
   }
 }
 
 void OmpStructureChecker::CheckThreadprivateOrDeclareTargetVar(
     const parser::OmpObjectList &objList) {
   for (const auto &ompObject : objList.v) {
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const parser::Designator &) {
               if (const auto *name{parser::Unwrap<parser::Name>(ompObject)}) {
                 const auto &declScope{
                     GetProgramUnitContaining(name->symbol->GetUltimate())};
                 const auto *sym =
                     declScope.parent().FindSymbol(name->symbol->name());
                 if (sym &&
bool OmpStructureChecker::IsOperatorValid(const T &node, const D &variable) {
   }
   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::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" ||
if (std::get_if<Fortran::parser::OmpMemoryOrderClause>(&clause.u)) {
             "allowed on OpenMP Atomic construct"_err_en_US);
         return;
       }
     }
   }
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPAtomicConstruct &x) {
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const parser::OmpAtomic &atomicConstruct) {
             const auto &dir{std::get<parser::Verbatim>(atomicConstruct.t)};
             PushContextAndClauseSets(
                 dir.source, llvm::omp::Directive::OMPD_atomic);
             CheckAtomicUpdateAssignmentStmt(
                 std::get<parser::Statement<parser::AssignmentStmt>>(
                     atomicConstruct.t)
OmpClauseSet threadprivateAllowedSet{llvm::omp::Clause::OMPC_copyin,
       llvm::omp::Clause::OMPC_num_threads, llvm::omp::Clause::OMPC_thread_limit,
       llvm::omp::Clause::OMPC_if};
   for (auto it : GetContext().clauseInfo) {
     llvmOmpClause type = it.first;
     const auto *clause = it.second;
     if (!threadprivateAllowedSet.test(type)) {
       if (const auto *objList{GetOmpObjectList(*clause)}) {
         for (const auto &ompObject : objList->v) {
-          std::visit(
+          common::visit(
               common::visitors{
                   [&](const parser::Designator &) {
                     if (const auto *name{
                             parser::Unwrap<parser::Name>(ompObject)})
                       testThreadprivateVarErr(
                           name->symbol->GetUltimate(), *name, type);
                   },
                   [&](const parser::Name &name) {
if (CheckReductionOperators(x)) {
     CheckReductionTypeList(x);
   }
 }
 bool OmpStructureChecker::CheckReductionOperators(
     const parser::OmpClause::Reduction &x) {
 
   const auto &definedOp{std::get<0>(x.v.t)};
   bool ok = false;
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const parser::DefinedOperator &dOpr) {
             const auto &intrinsicOp{
                 std::get<parser::DefinedOperator::IntrinsicOperator>(dOpr.u)};
             ok = CheckIntrinsicOperator(intrinsicOp);
           },
           [&](const parser::ProcedureDesignator &procD) {
             const parser::Name *name{std::get_if<parser::Name>(&procD.u)};

 }
 
 void OmpStructureChecker::CheckIsVarPartOfAnotherVar(
     const parser::CharBlock &source, const parser::OmpObjectList &objList) {
   OmpDirectiveSet nonPartialVarSet{llvm::omp::Directive::OMPD_allocate,
       llvm::omp::Directive::OMPD_threadprivate,
       llvm::omp::Directive::OMPD_declare_target};
   for (const auto &ompObject : objList.v) {
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const parser::Designator &designator) {
               if (const auto *dataRef{
                       std::get_if<parser::DataRef>(&designator.u)}) {
                 if (IsDataRefTypeParamInquiry(dataRef)) {
                   context_.Say(source,
                       "A type parameter inquiry cannot appear on the %s "
                       "directive"_err_en_US,

 }
 
 llvm::StringRef OmpStructureChecker::getDirectiveName(
     llvm::omp::Directive directive) {
   return llvm::omp::getOpenMPDirectiveName(directive);
 }
 
 void OmpStructureChecker::CheckDependList(const parser::DataRef &d) {
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const common::Indirection<parser::ArrayElement> &elem) {
             // Check if the base element is valid on Depend Clause
             CheckDependList(elem.value().base);
           },
           [&](const common::Indirection<parser::StructureComponent> &) {
             context_.Say(GetContext().clauseSource,
                 "A variable that is part of another variable "
using MemberObjectListClauses = std::tuple<parser::OmpClause::Copyprivate,
       parser::OmpClause::Shared, parser::OmpClause::To>;
 
   // Clauses with OmpObjectList in the tuple
   using TupleObjectListClauses = std::tuple<parser::OmpClause::Allocate,
       parser::OmpClause::Map, parser::OmpClause::Reduction>;
 
   // TODO:: Generate the tuples using TableGen.
   // Handle other constructs with OmpObjectList such as OpenMPThreadprivate.
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const auto &x) -> const parser::OmpObjectList * {
             using Ty = std::decay_t<decltype(x)>;
             if constexpr (common::HasMember<Ty, MemberObjectListClauses>) {
               return &x.v;
             } else if constexpr (common::HasMember<Ty,
                                      TupleObjectListClauses>) {
               return &(std::get<parser::OmpObjectList>(x.v.t));

flang/lib/Semantics/check-select-rank.cpp

void SelectRankConstructChecker::Leave(
   parser::CharBlock prevLocStar;
   std::optional<parser::CharBlock> caseForRank[common::maxRank + 1];
 
   for (const auto &rankCase : rankCaseList) {
     const auto &rankCaseStmt{
         std::get<parser::Statement<parser::SelectRankCaseStmt>>(rankCase.t)};
     const auto &rank{
         std::get<parser::SelectRankCaseStmt::Rank>(rankCaseStmt.statement.t)};
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const parser::Default &) { // C1153
               if (!defaultRankFound) {
                 defaultRankFound = true;
                 prevLocDefault = rankCaseStmt.source;
               } else {
                 context_
                     .Say(rankCaseStmt.source,
common::visit(
             },
         },
         rank.u);
   }
 }
 
 const SomeExpr *SelectRankConstructChecker::GetExprFromSelector(
     const parser::Selector &selector) {
-  return std::visit([](const auto &x) { return GetExpr(x); }, selector.u);
+  return common::visit([](const auto &x) { return GetExpr(x); }, selector.u);
 }
 
 } // namespace Fortran::semantics

flang/lib/Semantics/check-select-type.cpp

if (std::holds_alternative<parser::Default>(guard.u)) {
       }
     } else {
       hasErrors_ = true;
     }
   }
 
   std::optional<evaluate::DynamicType> GetGuardType(
       const parser::TypeGuardStmt::Guard &guard) {
-    return std::visit(
+    return common::visit(
         common::visitors{
             [](const parser::Default &)
                 -> std::optional<evaluate::DynamicType> {
               return std::nullopt;
             },
             [](const parser::TypeSpec &typeSpec) {
               return evaluate::DynamicType::From(typeSpec.declTypeSpec);
             },
             [](const parser::DerivedTypeSpec &spec)
                 -> std::optional<evaluate::DynamicType> {
               if (const auto *derivedTypeSpec{spec.derivedTypeSpec}) {
                 return evaluate::DynamicType(*derivedTypeSpec);
               }
               return std::nullopt;
             },
         },
         guard.u);
   }
 
   bool PassesChecksOnGuard(const parser::Statement<parser::TypeGuardStmt> &stmt,
       const evaluate::DynamicType &guardDynamicType) {
     const parser::TypeGuardStmt &typeGuardStmt{stmt.statement};
     const auto &guard{std::get<parser::TypeGuardStmt::Guard>(typeGuardStmt.t)};
-    return std::visit(
+    return common::visit(
         common::visitors{
             [](const parser::Default &) { return true; },
             [&](const parser::TypeSpec &typeSpec) {
               const DeclTypeSpec *spec{typeSpec.declTypeSpec};
               CHECK(spec);
               CHECK(spec->AsIntrinsic() || spec->AsDerived());
               bool typeSpecRetVal{false};
               if (spec->AsIntrinsic()) {
struct TypeCase {
     explicit TypeCase(const parser::Statement<parser::TypeGuardStmt> &s,
         std::optional<evaluate::DynamicType> guardTypeDynamic)
         : stmt{s} {
       SetGuardType(guardTypeDynamic);
     }
 
     void SetGuardType(std::optional<evaluate::DynamicType> guardTypeDynamic) {
       const auto &guard{GetGuardFromStmt(stmt)};
-      std::visit(common::visitors{
+      common::visit(common::visitors{
                         [&](const parser::Default &) {},
                         [&](const auto &) { guardType_ = *guardTypeDynamic; },
                     },
           guard.u);
     }
 
     bool IsDefault() const {
       const auto &guard{GetGuardFromStmt(stmt)};
       return std::holds_alternative<parser::Default>(guard.u);
     }
 
const auto &typeCaseList{
         std::get<std::list<parser::SelectTypeConstruct::TypeCase>>(
             construct.t)};
     TypeCaseValues{context_, *exprType}.Check(typeCaseList);
   }
 }
 
 const SomeExpr *SelectTypeChecker::GetExprFromSelector(
     const parser::Selector &selector) {
-  return std::visit([](const auto &x) { return GetExpr(x); }, selector.u);
+  return common::visit([](const auto &x) { return GetExpr(x); }, selector.u);
 }
 } // namespace Fortran::semantics

flang/lib/Semantics/data-to-inits.cpp

private:
   DataInitializations &inits_;
   evaluate::ExpressionAnalyzer &exprAnalyzer_;
   ValueListIterator<DSV> values_;
 };
 
 template <typename DSV>
 bool DataInitializationCompiler<DSV>::Scan(
     const parser::DataStmtObject &object) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const common::Indirection<parser::Variable> &var) {
             return Scan(var.value());
           },
           [&](const parser::DataImpliedDo &ido) { return Scan(ido); },
       },
       object.u);
 }
if (lowerExpr && upperExpr) {
     }
   }
   return false;
 }
 
 template <typename DSV>
 bool DataInitializationCompiler<DSV>::Scan(
     const parser::DataIDoObject &object) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const parser::Scalar<common::Indirection<parser::Designator>>
                   &var) { return Scan(var.thing.value()); },
           [&](const common::Indirection<parser::DataImpliedDo> &ido) {
             return Scan(ido.value());
           },
       },
       object.u);

flang/lib/Semantics/expression.cpp

 }
 
 // Applies subscripts to a data reference.
 MaybeExpr ExpressionAnalyzer::ApplySubscripts(
     DataRef &&dataRef, std::vector<Subscript> &&subscripts) {
   if (subscripts.empty()) {
     return std::nullopt; // error recovery
   }
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](SymbolRef &&symbol) {
             return CompleteSubscripts(ArrayRef{symbol, std::move(subscripts)});
           },
           [&](Component &&c) {
             return CompleteSubscripts(
                 ArrayRef{std::move(c), std::move(subscripts)});
           },
if (auto *ae{std::get_if<common::Indirection<parser::ArrayElement>>(
             &dataRef->u)}) {
       parser::ArrayElement &arrElement{ae->value()};
       if (!arrElement.subscripts.empty()) {
         auto iter{arrElement.subscripts.begin()};
         if (auto *triplet{std::get_if<parser::SubscriptTriplet>(&iter->u)}) {
           if (!std::get<2>(triplet->t) /* no stride */ &&
               ++iter == arrElement.subscripts.end() /* one subscript */) {
             if (Symbol *
-                symbol{std::visit(
+                symbol{common::visit(
                     common::visitors{
                         [](parser::Name &n) { return n.symbol; },
                         [](common::Indirection<parser::StructureComponent>
                                 &sc) { return sc.value().component.symbol; },
                         [](auto &) -> Symbol * { return nullptr; },
                     },
                     arrElement.base.u)}) {
               const Symbol &ultimate{symbol->GetUltimate()};

 }
 
 // Type kind parameter values for literal constants.
 int ExpressionAnalyzer::AnalyzeKindParam(
     const std::optional<parser::KindParam> &kindParam, int defaultKind) {
   if (!kindParam) {
     return defaultKind;
   }
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](std::uint64_t k) { return static_cast<int>(k); },
           [&](const parser::Scalar<
               parser::Integer<parser::Constant<parser::Name>>> &n) {
             if (MaybeExpr ie{Analyze(n)}) {
               if (std::optional<std::int64_t> i64{ToInt64(*ie)}) {
                 int iv = *i64;
                 if (iv == *i64) {
MaybeExpr ExpressionAnalyzer::Analyze(
   const parser::SubstringRange &range{std::get<parser::SubstringRange>(x.t)};
   std::optional<Expr<SubscriptInteger>> lower{
       GetSubstringBound(std::get<0>(range.t))};
   std::optional<Expr<SubscriptInteger>> upper{
       GetSubstringBound(std::get<1>(range.t))};
   if (MaybeExpr string{Analyze(std::get<parser::CharLiteralConstant>(x.t))}) {
     if (auto *charExpr{std::get_if<Expr<SomeCharacter>>(&string->u)}) {
       Expr<SubscriptInteger> length{
-          std::visit([](const auto &ckExpr) { return ckExpr.LEN().value(); },
+          common::visit([](const auto &ckExpr) { return ckExpr.LEN().value(); },
               charExpr->u)};
       if (!lower) {
         lower = Expr<SubscriptInteger>{1};
       }
       if (!upper) {
         upper = Expr<SubscriptInteger>{
             static_cast<std::int64_t>(ToInt64(length).value())};
       }
-      return std::visit(
+      return common::visit(
           [&](auto &&ckExpr) -> MaybeExpr {
             using Result = ResultType<decltype(ckExpr)>;
             auto *cp{std::get_if<Constant<Result>>(&ckExpr.u)};
             CHECK(DEREF(cp).size() == 1);
             StaticDataObject::Pointer staticData{StaticDataObject::Create()};
             staticData->set_alignment(Result::kind)
                 .set_itemBytes(Result::kind)
                 .Push(cp->GetScalarValue().value());
if (s) {
     return AsSubscript(Analyze(*s));
   } else {
     return std::nullopt;
   }
 }
 
 std::optional<Subscript> ExpressionAnalyzer::AnalyzeSectionSubscript(
     const parser::SectionSubscript &ss) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const parser::SubscriptTriplet &t) -> std::optional<Subscript> {
             const auto &lower{std::get<0>(t.t)};
             const auto &upper{std::get<1>(t.t)};
             const auto &stride{std::get<2>(t.t)};
             auto result{Triplet{
                 TripletPart(lower), TripletPart(upper), TripletPart(stride)}};
             if ((lower && !result.lower()) || (upper && !result.upper())) {
MaybeExpr ExpressionAnalyzer::Analyze(const parser::ArrayElement &ae) {
   auto restorer{GetContextualMessages().DiscardMessages()};
   AnalyzeSectionSubscripts(ae.subscripts);
   return std::nullopt;
 }
 
 // Type parameter inquiries apply to data references, but don't depend
 // on any trailing (co)subscripts.
 static NamedEntity IgnoreAnySubscripts(Designator<SomeDerived> &&designator) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](SymbolRef &&symbol) { return NamedEntity{symbol}; },
           [](Component &&component) {
             return NamedEntity{std::move(component)};
           },
           [](ArrayRef &&arrayRef) { return std::move(arrayRef.base()); },
           [](CoarrayRef &&coarrayRef) {
             return NamedEntity{coarrayRef.GetLastSymbol()};
MaybeExpr ExpressionAnalyzer::Analyze(const parser::StructureComponent &sc) {
   } else if (auto *details{sym->detailsIf<semantics::MiscDetails>()}) {
     // special part-ref: %re, %im, %kind, %len
     // Type errors are detected and reported in semantics.
     using MiscKind = semantics::MiscDetails::Kind;
     MiscKind kind{details->kind()};
     if (kind == MiscKind::ComplexPartRe || kind == MiscKind::ComplexPartIm) {
       if (auto *zExpr{std::get_if<Expr<SomeComplex>>(&base->u)}) {
         if (std::optional<DataRef> dataRef{ExtractDataRef(std::move(*zExpr))}) {
-          Expr<SomeReal> realExpr{std::visit(
+          Expr<SomeReal> realExpr{common::visit(
               [&](const auto &z) {
                 using PartType = typename ResultType<decltype(z)>::Part;
                 auto part{kind == MiscKind::ComplexPartRe
                         ? ComplexPart::Part::RE
                         : ComplexPart::Part::IM};
                 return AsCategoryExpr(Designator<PartType>{
                     ComplexPart{std::move(*dataRef), part}});
               },
if (cosubsOk && !reversed.empty()) {
       const Symbol &symbol{reversed.front()};
       if (numCosubscripts != symbol.Corank()) {
         Say("'%s' has corank %d, but coindexed reference has %d cosubscripts"_err_en_US,
             symbol.name(), symbol.Corank(), numCosubscripts);
       }
     }
     for (const auto &imageSelSpec :
         std::get<std::list<parser::ImageSelectorSpec>>(x.imageSelector.t)) {
-      std::visit(
+      common::visit(
           common::visitors{
               [&](const auto &x) { Analyze(x.v); },
           },
           imageSelSpec.u);
     }
     // Reverse the chain of symbols so that the base is first and coarray
     // ultimate component is last.
     if (cosubsOk) {

 
 // Inverts a collection of generic ArrayConstructorValues<SomeType> that
 // all happen to have the same actual type T into one ArrayConstructor<T>.
 template <typename T>
 ArrayConstructorValues<T> MakeSpecific(
     ArrayConstructorValues<SomeType> &&from) {
   ArrayConstructorValues<T> to;
   for (ArrayConstructorValue<SomeType> &x : from) {
-    std::visit(
+    common::visit(
         common::visitors{
             [&](common::CopyableIndirection<Expr<SomeType>> &&expr) {
               auto *typed{UnwrapExpr<Expr<T>>(expr.value())};
               to.Push(std::move(DEREF(typed)));
             },
             [&](ImpliedDo<SomeType> &&impliedDo) {
               to.Push(ImpliedDo<T>{impliedDo.name(),
                   std::move(impliedDo.lower()), std::move(impliedDo.upper()),
if (!(messageDisplayedSet_ & 8)) {
       messageDisplayedSet_ |= 8;
     }
     return;
   }
   DynamicTypeWithLength xType{dyType.value()};
   if (Expr<SomeCharacter> * charExpr{UnwrapExpr<Expr<SomeCharacter>>(*x)}) {
     CHECK(xType.category() == TypeCategory::Character);
     xType.length =
-        std::visit([](const auto &kc) { return kc.LEN(); }, charExpr->u);
+        common::visit([](const auto &kc) { return kc.LEN(); }, charExpr->u);
   }
   if (!type_) {
     // If there is no explicit type-spec in an array constructor, the type
     // of the array is the declared type of all of the elements, which must
     // be well-defined and all match.
     // TODO: Possible language extension: use the most general type of
     // the values as the type of a numeric constructed array, convert all
     // of the other values to that type.  Alternative: let the first value
if (auto cast{ConvertToType(*type_, std::move(*x))}) {
                         "be converted to the type of the array '%s'"_err_en_US,
           x->GetType()->AsFortran(), type_->AsFortran()); // C7111, C7112
       messageDisplayedSet_ |= 4;
     }
   }
 }
 
 void ArrayConstructorContext::Add(const parser::AcValue &x) {
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const parser::AcValue::Triplet &triplet) { Add(triplet); },
           [&](const common::Indirection<parser::Expr> &expr) {
             Add(expr.value());
           },
           [&](const common::Indirection<parser::AcImpliedDo> &impliedDo) {
             Add(impliedDo.value());
           },
for (const Symbol &symbol : components) {
     }
   }
 
   return AsMaybeExpr(Expr<SomeDerived>{std::move(result)});
 }
 
 static std::optional<parser::CharBlock> GetPassName(
     const semantics::Symbol &proc) {
-  return std::visit(
+  return common::visit(
       [](const auto &details) {
         if constexpr (std::is_base_of_v<semantics::WithPassArg,
                           std::decay_t<decltype(details)>>) {
           return details.passName();
         } else {
           return std::optional<parser::CharBlock>{};
         }
       },
auto ExpressionAnalyzer::AnalyzeProcedureComponentRef(
   CHECK(context_.AnyFatalError());
   return std::nullopt;
 }
 
 // Can actual be argument associated with dummy?
 static bool CheckCompatibleArgument(bool isElemental,
     const ActualArgument &actual, const characteristics::DummyArgument &dummy) {
   const auto *expr{actual.UnwrapExpr()};
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const characteristics::DummyDataObject &x) {
             if (x.attrs.test(characteristics::DummyDataObject::Attr::Pointer) &&
                 IsBareNullPointer(expr)) {
               // NULL() without MOLD= is compatible with any dummy data pointer
               // but cannot be allowed to lead to ambiguity.
               return true;
             } else if (!isElemental && actual.Rank() != x.type.Rank() &&
Say(dueToNullActuals
           : "No specific procedure of generic '%s' matches the actual arguments"_err_en_US,
       symbol.name());
 }
 
 auto ExpressionAnalyzer::GetCalleeAndArguments(
     const parser::ProcedureDesignator &pd, ActualArguments &&arguments,
     bool isSubroutine, bool mightBeStructureConstructor)
     -> std::optional<CalleeAndArguments> {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const parser::Name &name) {
             return GetCalleeAndArguments(name, std::move(arguments),
                 isSubroutine, mightBeStructureConstructor);
           },
           [&](const parser::ProcComponentRef &pcr) {
             return AnalyzeProcedureComponentRef(pcr, std::move(arguments));
           },
const Symbol *AssumedTypeDummy<parser::Name>(const parser::Name &name) {
   return nullptr;
 }
 template <typename A>
 static const Symbol *AssumedTypePointerOrAllocatableDummy(const A &object) {
   // It is illegal for allocatable of pointer objects to be TYPE(*), but at that
   // point it is is not guaranteed that it has been checked the object has
   // POINTER or ALLOCATABLE attribute, so do not assume nullptr can be directly
   // returned.
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const parser::StructureComponent &x) {
             return AssumedTypeDummy(x.component);
           },
           [&](const parser::Name &x) { return AssumedTypeDummy(x); },
       },
       object.u);
 }
const Assignment *ExpressionAnalyzer::Analyze(
   if (!x.typedAssignment) {
     MaybeExpr lhs{Analyze(std::get<parser::DataRef>(x.t))};
     MaybeExpr rhs{Analyze(std::get<parser::Expr>(x.t))};
     if (!lhs || !rhs) {
       x.typedAssignment.Reset(
           new GenericAssignmentWrapper{}, GenericAssignmentWrapper::Deleter);
     } else {
       Assignment assignment{std::move(*lhs), std::move(*rhs)};
-      std::visit(common::visitors{
-                     [&](const std::list<parser::BoundsRemapping> &list) {
-                       Assignment::BoundsRemapping bounds;
-                       for (const auto &elem : list) {
-                         auto lower{AsSubscript(Analyze(std::get<0>(elem.t)))};
-                         auto upper{AsSubscript(Analyze(std::get<1>(elem.t)))};
-                         if (lower && upper) {
-                           bounds.emplace_back(Fold(std::move(*lower)),
-                               Fold(std::move(*upper)));
-                         }
-                       }
-                       assignment.u = std::move(bounds);
-                     },
-                     [&](const std::list<parser::BoundsSpec> &list) {
-                       Assignment::BoundsSpec bounds;
-                       for (const auto &bound : list) {
-                         if (auto lower{AsSubscript(Analyze(bound.v))}) {
-                           bounds.emplace_back(Fold(std::move(*lower)));
-                         }
-                       }
-                       assignment.u = std::move(bounds);
-                     },
-                 },
+      common::visit(
+          common::visitors{
+                    bounds.emplace_back(
+                        Fold(std::move(*lower)), Fold(std::move(*upper)));
           std::get<parser::PointerAssignmentStmt::Bounds>(x.t).u);
       x.typedAssignment.Reset(
           new GenericAssignmentWrapper{std::move(assignment)},
           GenericAssignmentWrapper::Deleter);
     }
   }
   return common::GetPtrFromOptional(x.typedAssignment->v);
 }

 
 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::Concat &x) {
   ArgumentAnalyzer analyzer{*this};
   analyzer.Analyze(std::get<0>(x.t));
   analyzer.Analyze(std::get<1>(x.t));
   if (!analyzer.fatalErrors()) {
     if (analyzer.IsIntrinsicConcat()) {
       analyzer.CheckForNullPointer();
-      return std::visit(
+      return common::visit(
           [&](auto &&x, auto &&y) -> MaybeExpr {
             using T = ResultType<decltype(x)>;
             if constexpr (std::is_same_v<T, ResultType<decltype(y)>>) {
               return AsGenericExpr(Concat<T::kind>{std::move(x), std::move(y)});
             } else {
               DIE("different types for intrinsic concat");
             }
           },
static void FixMisparsedFunctionReference(
   using uType = std::decay_t<decltype(constU)>;
   auto &u{const_cast<uType &>(constU)};
   if (auto *func{
           std::get_if<common::Indirection<parser::FunctionReference>>(&u)}) {
     parser::FunctionReference &funcRef{func->value()};
     auto &proc{std::get<parser::ProcedureDesignator>(funcRef.v.t)};
     if (Symbol *
         origSymbol{
-            std::visit(common::visitors{
+            common::visit(common::visitors{
                               [&](parser::Name &name) { return name.symbol; },
                               [&](parser::ProcComponentRef &pcr) {
                                 return pcr.v.thing.component.symbol;
                               },
                           },
                 proc.u)}) {
       Symbol &symbol{origSymbol->GetUltimate()};
       if (symbol.has<semantics::ObjectEntityDetails>() ||
           symbol.has<semantics::AssocEntityDetails>()) {
         // Note that expression in AssocEntityDetails cannot be a procedure
         // pointer as per C1105 so this cannot be a function reference.
         if constexpr (common::HasMember<common::Indirection<parser::Designator>,
                           uType>) {

 
 Expr<SubscriptInteger> ExpressionAnalyzer::AnalyzeKindSelector(
     TypeCategory category,
     const std::optional<parser::KindSelector> &selector) {
   int defaultKind{GetDefaultKind(category)};
   if (!selector) {
     return Expr<SubscriptInteger>{defaultKind};
   }
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const parser::ScalarIntConstantExpr &x) {
             if (MaybeExpr kind{Analyze(x)}) {
               if (std::optional<std::int64_t> code{ToInt64(*kind)}) {
                 if (CheckIntrinsicKind(category, *code)) {
                   return Expr<SubscriptInteger>{*code};
                 }
               } else if (auto *intExpr{UnwrapExpr<Expr<SomeInteger>>(*kind)}) {

 }
 
 void ArgumentAnalyzer::Analyze(
     const parser::ActualArgSpec &arg, bool isSubroutine) {
   // TODO: Actual arguments that are procedures and procedure pointers need to
   // be detected and represented (they're not expressions).
   // TODO: C1534: Don't allow a "restricted" specific intrinsic to be passed.
   std::optional<ActualArgument> actual;
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const common::Indirection<parser::Expr> &x) {
             actual = AnalyzeExpr(x.value());
             SetArgSourceLocation(actual, x.value().source);
           },
           [&](const parser::AltReturnSpec &label) {
             if (!isSubroutine) {
               context_.Say("alternate return specification may not appear on"

flang/lib/Semantics/mod-file.cpp

if (IsGenericDefinedOp(symbol)) {
     return os << symbol.name();
   }
 }
 
 // Emit a symbol to decls_, except for bindings in a derived type (type-bound
 // procedures, type-bound generics, final procedures) which go to typeBindings.
 void ModFileWriter::PutSymbol(
     llvm::raw_ostream &typeBindings, const Symbol &symbol) {
-  std::visit(common::visitors{
-                 [&](const ModuleDetails &) { /* should be current module */ },
-                 [&](const DerivedTypeDetails &) { PutDerivedType(symbol); },
-                 [&](const SubprogramDetails &) { PutSubprogram(symbol); },
-                 [&](const GenericDetails &x) {
-                   if (symbol.owner().IsDerivedType()) {
-                     // generic binding
-                     for (const Symbol &proc : x.specificProcs()) {
-                       PutGenericName(typeBindings << "generic::", symbol)
-                           << "=>" << proc.name() << '\n';
-                     }
-                   } else {
-                     PutGeneric(symbol);
-                     if (x.specific()) {
-                       PutSymbol(typeBindings, *x.specific());
-                     }
-                     if (x.derivedType()) {
-                       PutSymbol(typeBindings, *x.derivedType());
-                     }
-                   }
-                 },
-                 [&](const UseDetails &) { PutUse(symbol); },
-                 [](const UseErrorDetails &) {},
-                 [&](const ProcBindingDetails &x) {
-                   bool deferred{symbol.attrs().test(Attr::DEFERRED)};
-                   typeBindings << "procedure";
-                   if (deferred) {
-                     typeBindings << '(' << x.symbol().name() << ')';
-                   }
-                   PutPassName(typeBindings, x.passName());
-                   auto attrs{symbol.attrs()};
-                   if (x.passName()) {
-                     attrs.reset(Attr::PASS);
-                   }
-                   PutAttrs(typeBindings, attrs);
-                   typeBindings << "::" << symbol.name();
-                   if (!deferred && x.symbol().name() != symbol.name()) {
-                     typeBindings << "=>" << x.symbol().name();
-                   }
-                   typeBindings << '\n';
-                 },
-                 [&](const NamelistDetails &x) {
-                   decls_ << "namelist/" << symbol.name();
-                   char sep{'/'};
-                   for (const Symbol &object : x.objects()) {
-                     decls_ << sep << object.name();
-                     sep = ',';
-                   }
-                   decls_ << '\n';
-                 },
-                 [&](const CommonBlockDetails &x) {
-                   decls_ << "common/" << symbol.name();
-                   char sep = '/';
-                   for (const auto &object : x.objects()) {
-                     decls_ << sep << object->name();
-                     sep = ',';
-                   }
-                   decls_ << '\n';
-                   if (symbol.attrs().test(Attr::BIND_C)) {
-                     PutAttrs(decls_, symbol.attrs(), x.bindName(), ""s);
-                     decls_ << "::/" << symbol.name() << "/\n";
-                   }
-                 },
-                 [](const HostAssocDetails &) {},
-                 [](const MiscDetails &) {},
-                 [&](const auto &) { PutEntity(decls_, symbol); },
-             },
+  common::visit(
+      common::visitors{
       symbol.details());
 }
 
 void ModFileWriter::PutDerivedType(
     const Symbol &typeSymbol, const Scope *scope) {
   auto &details{typeSymbol.get<DerivedTypeDetails>()};
   if (details.isDECStructure()) {
     PutDECStructure(typeSymbol, scope);
void CollectSymbols(
   for (const auto &pair : scope.commonBlocks()) {
     sorted.push_back(*pair.second);
   }
   std::sort(
       sorted.end() - commonSize, sorted.end(), SymbolSourcePositionCompare{});
 }
 
 void ModFileWriter::PutEntity(llvm::raw_ostream &os, const Symbol &symbol) {
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const ObjectEntityDetails &) { PutObjectEntity(os, symbol); },
           [&](const ProcEntityDetails &) { PutProcEntity(os, symbol); },
           [&](const TypeParamDetails &) { PutTypeParam(os, symbol); },
           [&](const auto &) {
             common::die("PutEntity: unexpected details: %s",
                 DetailsToString(symbol.details()).c_str());
           },
if (scope != scope_ && !scope.IsDerivedType()) {
     if (NeedImport(name, symbol)) {
       imports_.insert(name);
     }
     return;
   }
   if (!needSet_.insert(symbol).second) {
     return; // already done
   }
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [this](const ObjectEntityDetails &details) {
                       for (const ShapeSpec &spec : details.shape()) {
                         DoBound(spec.lbound());
                         DoBound(spec.ubound());
                       }
                       for (const ShapeSpec &spec : details.coshape()) {
                         DoBound(spec.lbound());
                         DoBound(spec.ubound());
                       }
                       if (const Symbol * commonBlock{details.commonBlock()}) {
                         DoSymbol(*commonBlock);
                       }
                     },
                     [this](const CommonBlockDetails &details) {
                       for (const auto &object : details.objects()) {
                         DoSymbol(*object);
                       }
                     },
                     [](const auto &) {},
                 },
       symbol.details());
   if (!symbol.has<UseDetails>()) {
     DoType(symbol.GetType());
   }
   if (!scope.IsDerivedType()) {
     need_.push_back(symbol);
   }
 }

flang/lib/Semantics/pointer-assignment.cpp

template <typename T> bool PointerAssignmentChecker::Check(const T &) {
   Say("Target associated with %s must be a designator or a call to a"
       " pointer-valued function"_err_en_US,
       description_);
   return false;
 }
 
 template <typename T>
 bool PointerAssignmentChecker::Check(const evaluate::Expr<T> &x) {
-  return std::visit([&](const auto &x) { return Check(x); }, x.u);
+  return common::visit([&](const auto &x) { return Check(x); }, x.u);
 }
 
 bool PointerAssignmentChecker::Check(const SomeExpr &rhs) {
   if (HasVectorSubscript(rhs)) { // C1025
     Say("An array section with a vector subscript may not be a pointer target"_err_en_US);
     return false;
   } else if (ExtractCoarrayRef(rhs)) { // C1026
     Say("A coindexed object may not be a pointer target"_err_en_US);
     return false;
   } else {
-    return std::visit([&](const auto &x) { return Check(x); }, rhs.u);
+    return common::visit([&](const auto &x) { return Check(x); }, rhs.u);
   }
 }
 
 bool PointerAssignmentChecker::Check(const evaluate::NullPointer &) {
   return true; // P => NULL() without MOLD=; always OK
 }
 
 template <typename T>

 // Verify that any bounds on the LHS of a pointer assignment are valid.
 // Return true if it is a bound-remapping so we can perform further checks.
 static bool CheckPointerBounds(
     evaluate::FoldingContext &context, const evaluate::Assignment &assignment) {
   auto &messages{context.messages()};
   const SomeExpr &lhs{assignment.lhs};
   const SomeExpr &rhs{assignment.rhs};
   bool isBoundsRemapping{false};
-  std::size_t numBounds{std::visit(
+  std::size_t numBounds{common::visit(
       common::visitors{
           [&](const evaluate::Assignment::BoundsSpec &bounds) {
             return bounds.size();
           },
           [&](const evaluate::Assignment::BoundsRemapping &bounds) {
             isBoundsRemapping = true;
             evaluate::ExtentExpr lhsSizeExpr{1};
             for (const auto &bound : bounds) {

flang/lib/Semantics/program-tree.cpp

const auto &subps{
       std::get<std::optional<parser::InternalSubprogramPart>>(x.t)};
   ProgramTree node{name, spec, &exec};
   GetEntryStmts(node, spec);
   GetEntryStmts(node, exec);
   GetGenerics(node, spec);
   if (subps) {
     for (const auto &subp :
         std::get<std::list<parser::InternalSubprogram>>(subps->t)) {
-      std::visit(
+      common::visit(
           [&](const auto &y) { node.AddChild(ProgramTree::Build(y.value())); },
           subp.u);
     }
   }
   return node;
 }
 
 static ProgramTree BuildSubprogramTree(
     const parser::Name &name, const parser::BlockData &x) {
   const auto &spec{std::get<parser::SpecificationPart>(x.t)};
   return ProgramTree{name, spec};
 }
 
 template <typename T>
 static ProgramTree BuildModuleTree(const parser::Name &name, const T &x) {
   const auto &spec{std::get<parser::SpecificationPart>(x.t)};
   const auto &subps{std::get<std::optional<parser::ModuleSubprogramPart>>(x.t)};
   ProgramTree node{name, spec};
   GetGenerics(node, spec);
   if (subps) {
     for (const auto &subp :
         std::get<std::list<parser::ModuleSubprogram>>(subps->t)) {
-      std::visit(
+      common::visit(
           [&](const auto &y) { node.AddChild(ProgramTree::Build(y.value())); },
           subp.u);
     }
   }
   return node;
 }
 
 ProgramTree ProgramTree::Build(const parser::ProgramUnit &x) {
-  return std::visit([](const auto &y) { return Build(y.value()); }, x.u);
+  return common::visit([](const auto &y) { return Build(y.value()); }, x.u);
 }
 
 ProgramTree ProgramTree::Build(const parser::MainProgram &x) {
   const auto &stmt{
       std::get<std::optional<parser::Statement<parser::ProgramStmt>>>(x.t)};
   const auto &end{std::get<parser::Statement<parser::EndProgramStmt>>(x.t)};
   static parser::Name emptyName;
   auto result{stmt ? BuildSubprogramTree(stmt->statement.v, x).set_stmt(*stmt)

 
 Symbol::Flag ProgramTree::GetSubpFlag() const {
   return GetKind() == Kind::Function ? Symbol::Flag::Function
                                      : Symbol::Flag::Subroutine;
 }
 
 bool ProgramTree::HasModulePrefix() const {
   using ListType = std::list<parser::PrefixSpec>;
-  const auto *prefixes{
-      std::visit(common::visitors{
-                     [](const parser::Statement<parser::FunctionStmt> *x) {
-                       return &std::get<ListType>(x->statement.t);
-                     },
-                     [](const parser::Statement<parser::SubroutineStmt> *x) {
-                       return &std::get<ListType>(x->statement.t);
-                     },
-                     [](const auto *) -> const ListType * { return nullptr; },
-                 },
-          stmt_)};
+  const auto *prefixes{common::visit(
+      common::visitors{
   if (prefixes) {
     for (const auto &prefix : *prefixes) {
       if (std::holds_alternative<parser::PrefixSpec::Module>(prefix.u)) {
         return true;
       }
     }
   }
   return false;
 }
 
 ProgramTree::Kind ProgramTree::GetKind() const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const parser::Statement<parser::ProgramStmt> *) {
             return Kind::Program;
           },
           [](const parser::Statement<parser::FunctionStmt> *) {
             return Kind::Function;
           },
           [](const parser::Statement<parser::SubroutineStmt> *) {

flang/lib/Semantics/resolve-directives.cpp

bool Pre(const parser::OmpClause::Copyin &x) {
     ResolveOmpObjectList(x.v, Symbol::Flag::OmpCopyIn);
     return false;
   }
   bool Pre(const parser::OmpClause::Copyprivate &x) {
     ResolveOmpObjectList(x.v, Symbol::Flag::OmpCopyPrivate);
     return false;
   }
   bool Pre(const parser::OmpLinearClause &x) {
-    std::visit(common::visitors{
+    common::visit(common::visitors{
                       [&](const parser::OmpLinearClause::WithoutModifier
                               &linearWithoutModifier) {
-                     ResolveOmpNameList(
-                         linearWithoutModifier.names, Symbol::Flag::OmpLinear);
+                        ResolveOmpNameList(linearWithoutModifier.names,
+                            Symbol::Flag::OmpLinear);
                       },
                       [&](const parser::OmpLinearClause::WithModifier
                               &linearWithModifier) {
                         ResolveOmpNameList(
                             linearWithModifier.names, Symbol::Flag::OmpLinear);
                       },
                   },
         x.u);
     return false;
   }
 
   bool Pre(const parser::OmpClause::Reduction &x) {
     const parser::OmpReductionOperator &opr{
         std::get<parser::OmpReductionOperator>(x.v.t)};
     if (const auto *procD{parser::Unwrap<parser::ProcedureDesignator>(opr.u)}) {
bool AccAttributeVisitor::Pre(const parser::OpenACCCombinedConstruct &x) {
   }
   ClearDataSharingAttributeObjects();
   return true;
 }
 
 static bool IsLastNameArray(const parser::Designator &designator) {
   const auto &name{GetLastName(designator)};
   const evaluate::DataRef dataRef{*(name.symbol)};
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const evaluate::SymbolRef &ref) { return ref->Rank() > 0; },
           [](const evaluate::ArrayRef &aref) {
             return aref.base().IsSymbol() ||
                 aref.base().GetComponent().base().Rank() == 0;
           },
           [](const auto &) { return false; },
       },
       dataRef.u);
 }
 
 void AccAttributeVisitor::AllowOnlyArrayAndSubArray(
     const parser::AccObjectList &objectList) {
   for (const auto &accObject : objectList.v) {
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const parser::Designator &designator) {
               if (!IsLastNameArray(designator)) {
                 context_.Say(designator.source,
                     "Only array element or subarray are allowed in %s directive"_err_en_US,
                     parser::ToUpperCaseLetters(
                         llvm::acc::getOpenACCDirectiveName(
                             GetContext().directive)
common::visit(
         },
         accObject.u);
   }
 }
 
 void AccAttributeVisitor::DoNotAllowAssumedSizedArray(
     const parser::AccObjectList &objectList) {
   for (const auto &accObject : objectList.v) {
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const parser::Designator &designator) {
               const auto &name{GetLastName(designator)};
               if (name.symbol && semantics::IsAssumedSizeArray(*name.symbol)) {
                 context_.Say(designator.source,
                     "Assumed-size dummy arrays may not appear on the %s "
                     "directive"_err_en_US,
                     parser::ToUpperCaseLetters(
for (const parser::DoConstruct *loop{&*outer}; loop && level > 0; --level) {
     loop = it != block.end() ? GetDoConstructIf(*it) : nullptr;
   }
   CHECK(level == 0);
 }
 
 void AccAttributeVisitor::EnsureAllocatableOrPointer(
     const llvm::acc::Clause clause, const parser::AccObjectList &objectList) {
   for (const auto &accObject : objectList.v) {
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const parser::Designator &designator) {
               const auto &lastName{GetLastName(designator)};
               if (!IsAllocatableOrPointer(*lastName.symbol)) {
                 context_.Say(designator.source,
                     "Argument `%s` on the %s clause must be a variable or "
                     "array with the POINTER or ALLOCATABLE attribute"_err_en_US,
                     lastName.symbol->name(),
void AccAttributeVisitor::ResolveAccObjectList(
     const parser::AccObjectList &accObjectList, Symbol::Flag accFlag) {
   for (const auto &accObject : accObjectList.v) {
     ResolveAccObject(accObject, accFlag);
   }
 }
 
 void AccAttributeVisitor::ResolveAccObject(
     const parser::AccObject &accObject, Symbol::Flag accFlag) {
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const parser::Designator &designator) {
             if (const auto *name{GetDesignatorNameIfDataRef(designator)}) {
               if (auto *symbol{ResolveAcc(*name, accFlag, currScope())}) {
                 AddToContextObjectWithDSA(*symbol, accFlag);
                 if (dataSharingAttributeFlags.test(accFlag)) {
                   CheckMultipleAppearances(*name, *symbol, accFlag);
                 }
void OmpAttributeVisitor::ResolveOmpObjectList(
     const parser::OmpObjectList &ompObjectList, Symbol::Flag ompFlag) {
   for (const auto &ompObject : ompObjectList.v) {
     ResolveOmpObject(ompObject, ompFlag);
   }
 }
 
 void OmpAttributeVisitor::ResolveOmpObject(
     const parser::OmpObject &ompObject, Symbol::Flag ompFlag) {
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const parser::Designator &designator) {
             if (const auto *name{GetDesignatorNameIfDataRef(designator)}) {
               if (auto *symbol{ResolveOmp(*name, ompFlag, currScope())}) {
                 if (dataCopyingAttributeFlags.test(ompFlag)) {
                   CheckDataCopyingClause(*name, *symbol, ompFlag);
                 } else {
                   AddToContextObjectWithDSA(*symbol, ompFlag);

flang/lib/Semantics/resolve-names-utils.cpp

 void GenericSpecInfo::Analyze(const parser::DefinedOpName &name) {
   kind_ = GenericKind::OtherKind::DefinedOp;
   parseName_ = &name.v;
   symbolName_ = name.v.source;
 }
 
 void GenericSpecInfo::Analyze(const parser::GenericSpec &x) {
   symbolName_ = x.source;
-  kind_ = std::visit(
+  kind_ = common::visit(
       common::visitors{
           [&](const parser::Name &y) -> GenericKind {
             parseName_ = &y;
             symbolName_ = y.source;
             return GenericKind::OtherKind::Name;
           },
           [&](const parser::DefinedOperator &y) {
-            return std::visit(
+            return common::visit(
                 common::visitors{
                     [&](const parser::DefinedOpName &z) -> GenericKind {
                       Analyze(z);
                       return GenericKind::OtherKind::DefinedOp;
                     },
                     [&](const IntrinsicOperator &z) {
                       return MapIntrinsicOperator(z);
                     },
return ArraySpecAnalyzer{context}.AnalyzeDeferredShapeSpecList(
       deferredShapeSpecs);
 }
 ArraySpec AnalyzeCoarraySpec(
     SemanticsContext &context, const parser::CoarraySpec &coarraySpec) {
   return ArraySpecAnalyzer{context}.Analyze(coarraySpec);
 }
 
 ArraySpec ArraySpecAnalyzer::Analyze(const parser::ComponentArraySpec &x) {
-  std::visit([this](const auto &y) { Analyze(y); }, x.u);
+  common::visit([this](const auto &y) { Analyze(y); }, x.u);
   CHECK(!arraySpec_.empty());
   return arraySpec_;
 }
 ArraySpec ArraySpecAnalyzer::Analyze(const parser::ArraySpec &x) {
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [&](const parser::AssumedSizeSpec &y) {
-                   Analyze(std::get<std::list<parser::ExplicitShapeSpec>>(y.t));
+                      Analyze(
+                          std::get<std::list<parser::ExplicitShapeSpec>>(y.t));
                       Analyze(std::get<parser::AssumedImpliedSpec>(y.t));
                     },
                     [&](const parser::ImpliedShapeSpec &y) { Analyze(y.v); },
                     [&](const auto &y) { Analyze(y); },
                 },
       x.u);
   CHECK(!arraySpec_.empty());
   return arraySpec_;
 }
 ArraySpec ArraySpecAnalyzer::AnalyzeDeferredShapeSpecList(
     const parser::DeferredShapeSpecList &x) {
   Analyze(x);
   CHECK(!arraySpec_.empty());
   return arraySpec_;
 }
 ArraySpec ArraySpecAnalyzer::Analyze(const parser::CoarraySpec &x) {
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const parser::DeferredCoshapeSpecList &y) { MakeDeferred(y.v); },
           [&](const parser::ExplicitCoshapeSpec &y) {
             Analyze(std::get<std::list<parser::ExplicitShapeSpec>>(y.t));
             MakeImplied(
                 std::get<std::optional<parser::SpecificationExpr>>(y.t));
           },
       },
for (const auto &obj : set) {
     if (obj.symbol == symbol) {
       return &obj;
     }
   }
   return nullptr;
 }
 
 bool EquivalenceSets::CheckDesignator(const parser::Designator &designator) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const parser::DataRef &x) {
             return CheckDataRef(designator.source, x);
           },
           [&](const parser::Substring &x) {
             const auto &dataRef{std::get<parser::DataRef>(x.t)};
             const auto &range{std::get<parser::SubstringRange>(x.t)};
             bool ok{CheckDataRef(designator.source, dataRef)};
             if (const auto &lb{std::get<0>(range.t)}) {
               ok &= CheckSubstringBound(lb->thing.thing.value(), true);
             } else {
               currObject_.substringStart = 1;
             }
             if (const auto &ub{std::get<1>(range.t)}) {
               ok &= CheckSubstringBound(ub->thing.thing.value(), false);
             }
             return ok;
           },
       },
       designator.u);
 }
 
 bool EquivalenceSets::CheckDataRef(
     const parser::CharBlock &source, const parser::DataRef &x) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const parser::Name &name) { return CheckObject(name); },
           [&](const common::Indirection<parser::StructureComponent> &) {
             context_.Say(source, // C8107
                 "Derived type component '%s' is not allowed in an equivalence set"_err_en_US,
                 source);
             return false;
           },
           [&](const common::Indirection<parser::ArrayElement> &elem) {
             bool ok{CheckDataRef(source, elem.value().base)};
             for (const auto &subscript : elem.value().subscripts) {
-              ok &= std::visit(
+              ok &= common::visit(
                   common::visitors{
                       [&](const parser::SubscriptTriplet &) {
                         context_.Say(source, // C924, R872
                             "Array section '%s' is not allowed in an equivalence set"_err_en_US,
                             source);
                         return false;
                       },
                       [&](const parser::IntExpr &y) {

flang/lib/Semantics/resolve-names.cpp

 #include "program-tree.h"
 #include "resolve-directives.h"
 #include "resolve-names-utils.h"
 #include "rewrite-parse-tree.h"
 #include "flang/Common/Fortran.h"
 #include "flang/Common/default-kinds.h"
 #include "flang/Common/indirection.h"
 #include "flang/Common/restorer.h"
+#include "flang/Common/visit.h"
 #include "flang/Evaluate/characteristics.h"
 #include "flang/Evaluate/check-expression.h"
 #include "flang/Evaluate/common.h"
 #include "flang/Evaluate/fold-designator.h"
 #include "flang/Evaluate/fold.h"
 #include "flang/Evaluate/intrinsics.h"
 #include "flang/Evaluate/tools.h"
 #include "flang/Evaluate/type.h"
Attrs AttrsVisitor::EndAttrs() {
   bindName_.reset();
   return result;
 }
 
 bool AttrsVisitor::SetPassNameOn(Symbol &symbol) {
   if (!passName_) {
     return false;
   }
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [&](ProcEntityDetails &x) { x.set_passName(*passName_); },
                     [&](ProcBindingDetails &x) { x.set_passName(*passName_); },
                     [](auto &) { common::die("unexpected pass name"); },
                 },
       symbol.details());
   return true;
 }
 
 void AttrsVisitor::SetBindNameOn(Symbol &symbol) {
   if (!attrs_ || !attrs_->test(Attr::BIND_C)) {
     return;
   }

 // ImplicitRulesVisitor implementation
 
 void ImplicitRulesVisitor::Post(const parser::ParameterStmt &) {
   prevParameterStmt_ = currStmtSource();
 }
 
 bool ImplicitRulesVisitor::Pre(const parser::ImplicitStmt &x) {
   bool result{
-      std::visit(common::visitors{
+      common::visit(common::visitors{
                         [&](const std::list<ImplicitNoneNameSpec> &y) {
                           return HandleImplicitNone(y);
                         },
                         [&](const std::list<parser::ImplicitSpec> &) {
                           if (prevImplicitNoneType_) {
                             Say("IMPLICIT statement after IMPLICIT NONE or "
                                 "IMPLICIT NONE(TYPE) statement"_err_en_US);
                             return false;
                           }
                           implicitRules_->set_isImplicitNoneType(false);
                           return true;
                         },
                     },
           x.u)};
   prevImplicit_ = currStmtSource();
   return result;
 }
 
 bool ImplicitRulesVisitor::Pre(const parser::LetterSpec &x) {
   auto loLoc{std::get<parser::Location>(x.t)};
   auto hiLoc{loLoc};

 
 void ScopeHandler::EraseSymbol(const parser::Name &name) {
   currScope().erase(name.source);
   name.symbol = nullptr;
 }
 
 static bool NeedsType(const Symbol &symbol) {
   return !symbol.GetType() &&
-      std::visit(common::visitors{
+      common::visit(common::visitors{
                         [](const EntityDetails &) { return true; },
                         [](const ObjectEntityDetails &) { return true; },
                         [](const AssocEntityDetails &) { return true; },
                         [&](const ProcEntityDetails &p) {
                           return symbol.test(Symbol::Flag::Function) &&
                               !symbol.attrs().test(Attr::INTRINSIC) &&
                               !p.interface().type() && !p.interface().symbol();
                         },
                         [](const auto &) { return false; },
                     },
           symbol.details());
 }
 
 void ScopeHandler::ApplyImplicitRules(
     Symbol &symbol, bool allowForwardReference) {
   if (context().HasError(symbol) || !NeedsType(symbol)) {
     return;
   }
if (symbol.attrs().test(Attr::INTRINSIC)) { // C840
           symbol.name());
     }
   }
 }
 
 // ModuleVisitor implementation
 
 bool ModuleVisitor::Pre(const parser::Only &x) {
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [&](const Indirection<parser::GenericSpec> &generic) {
                       GenericSpecInfo genericSpecInfo{generic.value()};
                       AddUseOnly(genericSpecInfo.symbolName());
                       AddUse(genericSpecInfo);
                     },
                     [&](const parser::Name &name) {
                       AddUseOnly(name.source);
                       Resolve(name, AddUse(name.source, name.source).use);
                     },
                     [&](const parser::Rename &rename) { Walk(rename); },
                 },
       x.u);
   return false;
 }
 
 bool ModuleVisitor::Pre(const parser::Rename::Names &x) {
   const auto &localName{std::get<0>(x.t)};
   const auto &useName{std::get<1>(x.t)};
   AddUseRename(useName.source);

 }
 
 void ModuleVisitor::Post(const parser::UseStmt &x) {
   if (const auto *list{std::get_if<std::list<parser::Rename>>(&x.u)}) {
     // Not a use-only: collect the names that were used in renames,
     // then add a use for each public name that was not renamed.
     std::set<SourceName> useNames;
     for (const auto &rename : *list) {
-      std::visit(common::visitors{
+      common::visit(common::visitors{
                         [&](const parser::Rename::Names &names) {
                           useNames.insert(std::get<1>(names.t).source);
                         },
                         [&](const parser::Rename::Operators &ops) {
                           useNames.insert(std::get<1>(ops.t).v.source);
                         },
                     },
           rename.u);
     }
     for (const auto &[name, symbol] : *useModuleScope_) {
       if (symbol->attrs().test(Attr::PUBLIC) && !IsUseRenamed(symbol->name()) &&
           (!symbol->attrs().test(Attr::INTRINSIC) ||
               symbol->has<UseDetails>()) &&
           !symbol->has<MiscDetails>() && useNames.count(name) == 0) {
         SourceName location{x.moduleName.source};
void SubprogramVisitor::Post(const parser::EntryStmt &stmt) {
   SubprogramDetails entryDetails;
   entryDetails.set_entryScope(inclusiveScope);
   if (inFunction) {
     // Create the entity to hold the function result, if necessary.
     Symbol *resultSymbol{nullptr};
     auto &effectiveResultName{*(resultName ? resultName : &name)};
     resultSymbol = FindInScope(currScope(), effectiveResultName);
     if (resultSymbol) { // C1574
-      std::visit(
+      common::visit(
           common::visitors{[](EntityDetails &x) { x.set_funcResult(true); },
               [](ObjectEntityDetails &x) { x.set_funcResult(true); },
               [](ProcEntityDetails &x) { x.set_funcResult(true); },
               [&](const auto &) {
                 Say2(effectiveResultName.source,
                     "'%s' was previously declared as an item that may not be used as a function result"_err_en_US,
                     resultSymbol->name(), "Previous declaration of '%s'"_en_US);
                 context().SetError(*resultSymbol);
if (inFunction) {
     }
     entryDetails.set_result(*resultSymbol);
   }
 
   for (const auto &dummyArg : std::get<std::list<parser::DummyArg>>(stmt.t)) {
     if (const auto *dummyName{std::get_if<parser::Name>(&dummyArg.u)}) {
       Symbol *dummy{FindSymbol(*dummyName)};
       if (dummy) {
-        std::visit(
+        common::visit(
             common::visitors{[](EntityDetails &x) { x.set_isDummy(); },
                 [](ObjectEntityDetails &x) { x.set_isDummy(); },
                 [](ProcEntityDetails &x) { x.set_isDummy(); },
                 [](SubprogramDetails &x) { x.set_isDummy(); },
                 [&](const auto &) {
                   Say2(dummyName->source,
                       "ENTRY dummy argument '%s' is previously declared as an item that may not be used as a dummy argument"_err_en_US,
                       dummy->name(), "Previous declaration of '%s'"_en_US);
if (scope == &currScope() && extends) {
       scope = scope->GetDerivedTypeParent();
     }
   }
   return true;
 }
 
 ParamValue DeclarationVisitor::GetParamValue(
     const parser::TypeParamValue &x, common::TypeParamAttr attr) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [=](const parser::ScalarIntExpr &x) { // C704
             return ParamValue{EvaluateIntExpr(x), attr};
           },
           [=](const parser::Star &) { return ParamValue::Assumed(attr); },
           [=](const parser::TypeParamValue::Deferred &) {
             return ParamValue::Deferred(attr);
           },
bool ConstructVisitor::Pre(const parser::DataImpliedDo &x) {
   }
   return false;
 }
 
 // Sets InDataStmt flag on a variable (or misidentified function) in a DATA
 // statement so that the predicate IsInitialized() will be true
 // during semantic analysis before the symbol's initializer is constructed.
 bool ConstructVisitor::Pre(const parser::DataIDoObject &x) {
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const parser::Scalar<Indirection<parser::Designator>> &y) {
             Walk(y.thing.value());
             const parser::Name &first{parser::GetFirstName(y.thing.value())};
             if (first.symbol) {
               first.symbol->set(Symbol::Flag::InDataStmt);
             }
           },
           [&](const Indirection<parser::DataImpliedDo> &y) { Walk(y.value()); },
       },
       x.u);
   return false;
 }
 
 bool ConstructVisitor::Pre(const parser::DataStmtObject &x) {
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [&](const Indirection<parser::Variable> &y) {
                       Walk(y.value());
-                   const parser::Name &first{parser::GetFirstName(y.value())};
+                      const parser::Name &first{
+                          parser::GetFirstName(y.value())};
                       if (first.symbol) {
                         first.symbol->set(Symbol::Flag::InDataStmt);
                       }
                     },
                     [&](const parser::DataImpliedDo &y) {
                       PushScope(Scope::Kind::ImpliedDos, nullptr);
                       Walk(y);
                       PopScope();
                     },
                 },
       x.u);
   return false;
 }
 
 bool ConstructVisitor::Pre(const parser::DataStmtValue &x) {
   const auto &data{std::get<parser::DataStmtConstant>(x.t)};
   auto &mutableData{const_cast<parser::DataStmtConstant &>(data)};
   if (auto *elem{parser::Unwrap<parser::ArrayElement>(mutableData)}) {
void ConstructVisitor::SetTypeFromAssociation(Symbol &symbol) {
   }
   if (*pexpr) {
     const SomeExpr &expr{**pexpr};
     if (std::optional<evaluate::DynamicType> type{expr.GetType()}) {
       if (const auto *charExpr{
               evaluate::UnwrapExpr<evaluate::Expr<evaluate::SomeCharacter>>(
                   expr)}) {
         symbol.SetType(ToDeclTypeSpec(std::move(*type),
-            FoldExpr(
-                std::visit([](const auto &kindChar) { return kindChar.LEN(); },
-                    charExpr->u))));
+            FoldExpr(common::visit(
+                [](const auto &kindChar) { return kindChar.LEN(); },
       } else {
         symbol.SetType(ToDeclTypeSpec(std::move(*type)));
       }
     } else {
       // BOZ literals, procedure designators, &c. are not acceptable
       Say(symbol.name(), "Associate name '%s' must have a type"_err_en_US);
     }
   }
 }
 
 // If current selector is a variable, set some of its attributes on symbol.
 void ConstructVisitor::SetAttrsFromAssociation(Symbol &symbol) {
   Attrs attrs{evaluate::GetAttrs(GetCurrentAssociation().selector.expr)};
   symbol.attrs() |= attrs &
       Attrs{Attr::TARGET, Attr::ASYNCHRONOUS, Attr::VOLATILE, Attr::CONTIGUOUS};
   if (attrs.test(Attr::POINTER)) {
     symbol.attrs().set(Attr::TARGET);
   }
 }
 
 ConstructVisitor::Selector ConstructVisitor::ResolveSelector(
     const parser::Selector &x) {
-  return std::visit(common::visitors{
+  return common::visit(common::visitors{
                            [&](const parser::Expr &expr) {
                              return Selector{expr.source, EvaluateExpr(x)};
                            },
                            [&](const parser::Variable &var) {
                              return Selector{var.GetSource(), EvaluateExpr(x)};
                            },
                        },
       x.u);
 }
 
 // Set the current association to the nth to the last association on the
 // association stack.  The top of the stack is at n = 1.  This allows access
 // to the interior of a list of associations at the top of the stack.
 void ConstructVisitor::SetCurrentAssociation(std::size_t n) {
   CHECK(n > 0 && n <= associationStack_.size());

 
 const parser::Name *DeclarationVisitor::ResolveStructureComponent(
     const parser::StructureComponent &x) {
   return FindComponent(ResolveDataRef(x.base), x.component);
 }
 
 const parser::Name *DeclarationVisitor::ResolveDesignator(
     const parser::Designator &x) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const parser::DataRef &x) { return ResolveDataRef(x); },
           [&](const parser::Substring &x) {
             return ResolveDataRef(std::get<parser::DataRef>(x.t));
           },
       },
       x.u);
 }
 
 const parser::Name *DeclarationVisitor::ResolveDataRef(
     const parser::DataRef &x) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [=](const parser::Name &y) { return ResolveName(y); },
           [=](const Indirection<parser::StructureComponent> &y) {
             return ResolveStructureComponent(y.value());
           },
           [&](const Indirection<parser::ArrayElement> &y) {
             Walk(y.value().subscripts);
             const parser::Name *name{ResolveDataRef(y.value().base)};
void DeclarationVisitor::Initialization(const parser::Name &name,
   Symbol &ultimate{name.symbol->GetUltimate()};
   if (IsAllocatable(ultimate)) {
     Say(name, "Allocatable object '%s' cannot be initialized"_err_en_US);
     return;
   }
   if (auto *object{ultimate.detailsIf<ObjectEntityDetails>()}) {
     // TODO: check C762 - all bounds and type parameters of component
     // are colons or constant expressions if component is initialized
-    std::visit(
+    common::visit(
         common::visitors{
             [&](const parser::ConstantExpr &expr) {
               NonPointerInitialization(name, expr);
             },
             [&](const parser::NullInit &null) {
               Walk(null);
               if (auto nullInit{EvaluateExpr(null)}) {
                 if (!evaluate::IsNullPointer(*nullInit)) {
if (!context().HasError(ultimate) && !context().HasError(name.symbol)) {
         }
       }
     }
   }
 }
 
 void ResolveNamesVisitor::HandleCall(
     Symbol::Flag procFlag, const parser::Call &call) {
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const parser::Name &x) { HandleProcedureName(procFlag, x); },
           [&](const parser::ProcComponentRef &x) { Walk(x); },
       },
       std::get<parser::ProcedureDesignator>(call.t).u);
   Walk(std::get<std::list<parser::ActualArgSpec>>(call.t));
 }
 
if (accessIds.empty()) {
     if (prevAccessStmt_) { // C869
       Say("The default accessibility of this module has already been declared"_err_en_US)
           .Attach(*prevAccessStmt_, "Previous declaration"_en_US);
     }
     prevAccessStmt_ = currStmtSource();
     defaultAccess_ = accessAttr;
   } else {
     for (const auto &accessId : accessIds) {
-      std::visit(
+      common::visit(
           common::visitors{
               [=](const parser::Name &y) {
                 Resolve(y, SetAccess(y.source, accessAttr));
               },
               [=](const Indirection<parser::GenericSpec> &y) {
                 auto info{GenericSpecInfo{y.value()}};
                 const auto &symbolName{info.symbolName()};
                 if (auto *symbol{FindInScope(symbolName)}) {
bool ResolveNamesVisitor::Pre(const parser::SpecificationPart &x) {
   Walk(decls);
   FinishSpecificationPart(decls);
   return false;
 }
 
 // Initial processing on specification constructs, before visiting them.
 void ResolveNamesVisitor::PreSpecificationConstruct(
     const parser::SpecificationConstruct &spec) {
-  std::visit(
+  common::visit(
       common::visitors{
           [&](const parser::Statement<Indirection<parser::GenericStmt>> &y) {
             CreateGeneric(std::get<parser::GenericSpec>(y.statement.value().t));
           },
           [&](const Indirection<parser::InterfaceBlock> &y) {
             const auto &stmt{std::get<parser::Statement<parser::InterfaceStmt>>(
                 y.value().t)};
             if (const auto *spec{parser::Unwrap<parser::GenericSpec>(stmt)}) {

 }
 
 bool ResolveNamesVisitor::Pre(const parser::ImplicitStmt &x) {
   return CheckNotInBlock("IMPLICIT") && // C1107
       ImplicitRulesVisitor::Pre(x);
 }
 
 void ResolveNamesVisitor::Post(const parser::PointerObject &x) {
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [&](const parser::Name &x) { ResolveName(x); },
                     [&](const parser::StructureComponent &x) {
                       ResolveStructureComponent(x);
                     },
                 },
       x.u);
 }
 void ResolveNamesVisitor::Post(const parser::AllocateObject &x) {
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [&](const parser::Name &x) { ResolveName(x); },
                     [&](const parser::StructureComponent &x) {
                       ResolveStructureComponent(x);
                     },
                 },
       x.u);
 }
 
 bool ResolveNamesVisitor::Pre(const parser::PointerAssignmentStmt &x) {
   const auto &dataRef{std::get<parser::DataRef>(x.t)};
   const auto &bounds{std::get<parser::PointerAssignmentStmt::Bounds>(x.t)};
   const auto &expr{std::get<parser::Expr>(x.t)};
   ResolveDataRef(dataRef);
void ResolveNamesVisitor::ResolveSpecificationParts(ProgramTree &node) {
   }
   node.set_isSpecificationPartResolved();
   if (!BeginScopeForNode(node)) {
     return; // an error prevented scope from being created
   }
   Scope &scope{currScope()};
   node.set_scope(scope);
   AddSubpNames(node);
-  std::visit(
+  common::visit(
       [&](const auto *x) {
         if (x) {
           Walk(*x);
         }
       },
       node.stmt());
   Walk(node.spec());
   // If this is a function, convert result to an object. This is to prevent the

flang/lib/Semantics/rewrite-parse-tree.cpp

void RewriteMutator::Post(parser::IoUnit &x) {
   if (auto *var{std::get_if<parser::Variable>(&x.u)}) {
     const parser::Name &last{parser::GetLastName(*var)};
     DeclTypeSpec *type{last.symbol ? last.symbol->GetType() : nullptr};
     if (!type || type->category() != DeclTypeSpec::Character) {
       // If the Variable is not known to be character (any kind), transform
       // the I/O unit in situ to a FileUnitNumber so that automatic expression
       // constraint checking will be applied.
       auto source{var->GetSource()};
-      auto expr{std::visit(
+      auto expr{common::visit(
           [](auto &&indirection) {
             return parser::Expr{std::move(indirection)};
           },
           std::move(var->u))};
       expr.source = source;
       x.u = parser::FileUnitNumber{
           parser::ScalarIntExpr{parser::IntExpr{std::move(expr)}}};
     }

 // an internal I/O unit for unformatted I/O, which Fortran does
 // not support.
 void RewriteMutator::Post(parser::ReadStmt &x) {
   if (x.iounit && !x.format && x.controls.empty()) {
     if (auto *var{std::get_if<parser::Variable>(&x.iounit->u)}) {
       const parser::Name &last{parser::GetLastName(*var)};
       DeclTypeSpec *type{last.symbol ? last.symbol->GetType() : nullptr};
       if (type && type->category() == DeclTypeSpec::Character) {
-        x.format = std::visit(
+        x.format = common::visit(
             [](auto &&indirection) {
               return parser::Expr{std::move(indirection)};
             },
             std::move(var->u));
         x.iounit.reset();
       }
     }
   }

flang/lib/Semantics/runtime-type-info.cpp

const Symbol *RuntimeTableBuilder::DescribeType(Scope &dtScope) {
   // Traverse the components of the derived type
   if (!isPDTdefinitionWithKindParameters) {
     std::vector<const Symbol *> dataComponentSymbols;
     std::vector<evaluate::StructureConstructor> procPtrComponents;
     std::map<int, evaluate::StructureConstructor> specials;
     for (const auto &pair : dtScope) {
       const Symbol &symbol{*pair.second};
       auto locationRestorer{common::ScopedSet(location_, symbol.name())};
-      std::visit(
+      common::visit(
           common::visitors{
               [&](const TypeParamDetails &) {
                 // already handled above in declaration order
               },
               [&](const ObjectEntityDetails &) {
                 dataComponentSymbols.push_back(&symbol);
               },
               [&](const ProcEntityDetails &proc) {
AddValue(values, bindingSchema_, "name"s,
         SaveNameAsPointerTarget(scope, symbol->name().ToString()));
     result.emplace_back(DEREF(bindingSchema_.AsDerived()), std::move(values));
   }
   return result;
 }
 
 void RuntimeTableBuilder::DescribeGeneric(const GenericDetails &generic,
     std::map<int, evaluate::StructureConstructor> &specials) {
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [&](const GenericKind::OtherKind &k) {
                       if (k == GenericKind::OtherKind::Assignment) {
                         for (auto ref : generic.specificProcs()) {
                           DescribeSpecialProc(specials, *ref, true,
                               false /*!final*/, std::nullopt);
                         }
                       }
                     },
                     [&](const GenericKind::DefinedIo &io) {
                       switch (io) {
                       case GenericKind::DefinedIo::ReadFormatted:
                       case GenericKind::DefinedIo::ReadUnformatted:
                       case GenericKind::DefinedIo::WriteFormatted:
                       case GenericKind::DefinedIo::WriteUnformatted:
                         for (auto ref : generic.specificProcs()) {
                           DescribeSpecialProc(
                               specials, *ref, false, false /*!final*/, io);
                         }
                         break;
                       }
                     },
                     [](const auto &) {},
                 },
       generic.kind().u);
 }
 
 void RuntimeTableBuilder::DescribeSpecialProc(
     std::map<int, evaluate::StructureConstructor> &specials,
     const Symbol &specificOrBinding, bool isAssignment, bool isFinal,
     std::optional<GenericKind::DefinedIo> io) {
   const auto *binding{specificOrBinding.detailsIf<ProcBindingDetails>()};

flang/lib/Semantics/symbol.cpp

if (std::find_if(specificProcs_.begin(), specificProcs_.end(),
       bindingNames_.push_back(from.bindingNames_[i]);
     }
   }
 }
 
 // The name of the kind of details for this symbol.
 // This is primarily for debugging.
 std::string DetailsToString(const Details &details) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const UnknownDetails &) { return "Unknown"; },
           [](const MainProgramDetails &) { return "MainProgram"; },
           [](const ModuleDetails &) { return "Module"; },
           [](const SubprogramDetails &) { return "Subprogram"; },
           [](const SubprogramNameDetails &) { return "SubprogramName"; },
           [](const EntityDetails &) { return "Entity"; },
           [](const ObjectEntityDetails &) { return "ObjectEntity"; },
void Symbol::set_details(Details &&details) {
   CHECK(CanReplaceDetails(details));
   details_ = std::move(details);
 }
 
 bool Symbol::CanReplaceDetails(const Details &details) const {
   if (has<UnknownDetails>()) {
     return true; // can always replace UnknownDetails
   } else {
-    return std::visit(
+    return common::visit(
         common::visitors{
             [](const UseErrorDetails &) { return true; },
             [&](const ObjectEntityDetails &) { return has<EntityDetails>(); },
             [&](const ProcEntityDetails &) { return has<EntityDetails>(); },
             [&](const SubprogramDetails &) {
               return has<SubprogramNameDetails>() || has<EntityDetails>();
             },
             [&](const DerivedTypeDetails &) {

 // Usually a symbol's name is the first occurrence in the source, but sometimes
 // we want to replace it with one at a different location (but same characters).
 void Symbol::ReplaceName(const SourceName &name) {
   CHECK(name == name_);
   name_ = name;
 }
 
 void Symbol::SetType(const DeclTypeSpec &type) {
-  std::visit(common::visitors{
+  common::visit(common::visitors{
                     [&](EntityDetails &x) { x.set_type(type); },
                     [&](ObjectEntityDetails &x) { x.set_type(type); },
                     [&](AssocEntityDetails &x) { x.set_type(type); },
                     [&](ProcEntityDetails &x) { x.interface().set_type(type); },
                     [&](TypeParamDetails &x) { x.set_type(type); },
                     [](auto &) {},
                 },
       details_);
 }
 
 template <typename T>
 constexpr bool HasBindName{std::is_convertible_v<T, const WithBindName *>};
 
 const std::string *Symbol::GetBindName() const {
-  return std::visit(
+  return common::visit(
       [&](auto &x) -> const std::string * {
         if constexpr (HasBindName<decltype(&x)>) {
           return x.bindName();
         } else {
           return nullptr;
         }
       },
       details_);
 }
 
 void Symbol::SetBindName(std::string &&name) {
-  std::visit(
+  common::visit(
       [&](auto &x) {
         if constexpr (HasBindName<decltype(&x)>) {
           x.set_bindName(std::move(name));
         } else {
           DIE("bind name not allowed on this kind of symbol");
         }
       },
       details_);
 }
 
 bool Symbol::IsFuncResult() const {
-  return std::visit(
+  return common::visit(
       common::visitors{[](const EntityDetails &x) { return x.isFuncResult(); },
           [](const ObjectEntityDetails &x) { return x.isFuncResult(); },
           [](const ProcEntityDetails &x) { return x.isFuncResult(); },
           [](const HostAssocDetails &x) { return x.symbol().IsFuncResult(); },
           [](const auto &) { return false; }},
       details_);
 }
 
 bool Symbol::IsObjectArray() const {
   const auto *details{std::get_if<ObjectEntityDetails>(&details_)};
   return details && details->IsArray();
 }
 
 bool Symbol::IsSubprogram() const {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const SubprogramDetails &) { return true; },
           [](const SubprogramNameDetails &) { return true; },
           [](const GenericDetails &) { return true; },
           [](const UseDetails &x) { return x.symbol().IsSubprogram(); },
           [](const auto &) { return false; },
       },
       details_);
llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const GenericDetails &x) {
   }
   os << " procs:";
   DumpSymbolVector(os, x.specificProcs());
   return os;
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Details &details) {
   os << DetailsToString(details);
-  std::visit( //
+  common::visit( //
       common::visitors{
           [&](const UnknownDetails &) {},
           [&](const MainProgramDetails &) {},
           [&](const ModuleDetails &x) {
             if (x.isSubmodule()) {
               os << " (";
               if (x.ancestor()) {
                 auto ancestor{x.ancestor()->GetName().value()};
return Is(OtherKind::Concat) || Has<common::LogicalOperator>() ||
       Has<common::NumericOperator>() || Has<common::RelationalOperator>();
 }
 
 bool GenericKind::IsOperator() const {
   return IsDefinedOperator() || IsIntrinsicOperator();
 }
 
 std::string GenericKind::ToString() const {
-  return std::visit(
+  return common::visit(
       common::visitors {
         [](const OtherKind &x) { return EnumToString(x); },
             [](const DefinedIo &x) { return AsFortran(x).ToString(); },
 #if !__clang__ && __GNUC__ == 7 && __GNUC_MINOR__ == 2
             [](const common::NumericOperator &x) {
               return common::EnumToString(x);
             },
             [](const common::LogicalOperator &x) {

flang/lib/Semantics/tools.cpp

 }
 const evaluate::Assignment *GetAssignment(
     const parser::PointerAssignmentStmt &x) {
   CheckMissingAnalysis(!x.typedAssignment, x);
   return common::GetPtrFromOptional(x.typedAssignment->v);
 }
 
 const Symbol *FindInterface(const Symbol &symbol) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const ProcEntityDetails &details) {
             return details.interface().symbol();
           },
           [](const ProcBindingDetails &details) { return &details.symbol(); },
           [](const auto &) -> const Symbol * { return nullptr; },
       },
       symbol.details());
 }
 
 const Symbol *FindSubprogram(const Symbol &symbol) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const ProcEntityDetails &details) -> const Symbol * {
             if (const Symbol * interface{details.interface().symbol()}) {
               return FindSubprogram(*interface);
             } else {
               return &symbol;
             }
           },
if (auto *name{std::get_if<parser::Name>(&procedureDesignator.u)}) {
             return HasCoarray(argExpr->value());
           }
         }
       }
     }
     return false;
   }
   bool operator()(const parser::Statement<parser::ActionStmt> &stmt) {
-    return std::visit(*this, stmt.statement.u);
+    return common::visit(*this, stmt.statement.u);
   }
 
 private:
   bool IsCoarrayObject(const parser::AllocateObject &allocateObject) {
     const parser::Name &name{GetLastName(allocateObject)};
     return name.symbol && evaluate::IsCoarray(*name.symbol);
   }
 };
 
 bool IsImageControlStmt(const parser::ExecutableConstruct &construct) {
-  return std::visit(ImageControlStmtHelper{}, construct.u);
+  return common::visit(ImageControlStmtHelper{}, construct.u);
 }
 
 std::optional<parser::MessageFixedText> GetImageControlStmtCoarrayMsg(
     const parser::ExecutableConstruct &construct) {
   if (const auto *actionStmt{
           std::get_if<parser::Statement<parser::ActionStmt>>(&construct.u)}) {
-    return std::visit(
+    return common::visit(
         common::visitors{
             [](const common::Indirection<parser::AllocateStmt> &)
                 -> std::optional<parser::MessageFixedText> {
               return "ALLOCATE of a coarray is an image control"
                      " statement"_en_US;
             },
             [](const common::Indirection<parser::DeallocateStmt> &)
                 -> std::optional<parser::MessageFixedText> {
return common::visit(
         },
         actionStmt->statement.u);
   }
   return std::nullopt;
 }
 
 parser::CharBlock GetImageControlStmtLocation(
     const parser::ExecutableConstruct &executableConstruct) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [](const common::Indirection<parser::ChangeTeamConstruct>
                   &construct) {
             return std::get<parser::Statement<parser::ChangeTeamStmt>>(
                 construct.value().t)
                 .source;
           },
           [](const common::Indirection<parser::CriticalConstruct> &construct) {

 
 bool InCommonBlock(const Symbol &symbol) {
   const auto *details{symbol.detailsIf<ObjectEntityDetails>()};
   return details && details->commonBlock();
 }
 
 const std::optional<parser::Name> &MaybeGetNodeName(
     const ConstructNode &construct) {
-  return std::visit(
+  return common::visit(
       common::visitors{
           [&](const parser::BlockConstruct *blockConstruct)
               -> const std::optional<parser::Name> & {
             return std::get<0>(blockConstruct->t).statement.v;
           },
           [&](const auto *a) -> const std::optional<parser::Name> & {
             return std::get<0>(std::get<0>(a->t).statement.t);
           },

flang/runtime/io-stmt.h

 #ifndef FORTRAN_RUNTIME_IO_STMT_H_
 #define FORTRAN_RUNTIME_IO_STMT_H_
 
 #include "connection.h"
 #include "file.h"
 #include "format.h"
 #include "internal-unit.h"
 #include "io-error.h"
+#include "flang/Common/visit.h"
 #include "flang/Runtime/descriptor.h"
 #include "flang/Runtime/io-api.h"
 #include <functional>
 #include <type_traits>
 #include <variant>
 
 namespace Fortran::runtime::io {
 
public:
   void GotChar(signed int = 1); // for READ(SIZE=); can be <0
 
   MutableModes &mutableModes();
   ConnectionState &GetConnectionState();
   IoErrorHandler &GetIoErrorHandler() const;
 
   // N.B.: this also works with base classes
   template <typename A> A *get_if() const {
-    return std::visit(
+    return common::visit(
         [](auto &x) -> A * {
           if constexpr (std::is_convertible_v<decltype(x.get()), A &>) {
             return &x.get();
           }
           return nullptr;
         },
         u_);
   }

flang/runtime/io-stmt.cpp

 
 template <Direction DIR, typename CHAR>
 int ExternalFormattedIoStatementState<DIR, CHAR>::EndIoStatement() {
   CompleteOperation();
   return ExternalIoStatementState<DIR>::EndIoStatement();
 }
 
 std::optional<DataEdit> IoStatementState::GetNextDataEdit(int n) {
-  return std::visit(
+  return common::visit(
       [&](auto &x) { return x.get().GetNextDataEdit(*this, n); }, u_);
 }
 
 bool IoStatementState::Emit(
     const char *data, std::size_t n, std::size_t elementBytes) {
-  return std::visit(
+  return common::visit(
       [=](auto &x) { return x.get().Emit(data, n, elementBytes); }, u_);
 }
 
 bool IoStatementState::Emit(const char *data, std::size_t n) {
-  return std::visit([=](auto &x) { return x.get().Emit(data, n); }, u_);
+  return common::visit([=](auto &x) { return x.get().Emit(data, n); }, u_);
 }
 
 bool IoStatementState::Emit(const char16_t *data, std::size_t chars) {
-  return std::visit([=](auto &x) { return x.get().Emit(data, chars); }, u_);
+  return common::visit([=](auto &x) { return x.get().Emit(data, chars); }, u_);
 }
 
 bool IoStatementState::Emit(const char32_t *data, std::size_t chars) {
-  return std::visit([=](auto &x) { return x.get().Emit(data, chars); }, u_);
+  return common::visit([=](auto &x) { return x.get().Emit(data, chars); }, u_);
 }
 
 template <typename CHAR>
 bool IoStatementState::EmitEncoded(const CHAR *data0, std::size_t chars) {
   // Don't allow sign extension
   using UnsignedChar = std::make_unsigned_t<CHAR>;
   const UnsignedChar *data{reinterpret_cast<const UnsignedChar *>(data0)};
   if (GetConnectionState().isUTF8) {
if (GetConnectionState().isUTF8) {
     return at == 0 || Emit(buffer, at);
   } else {
     return Emit(data0, chars);
   }
 }
 
 bool IoStatementState::Receive(
     char *data, std::size_t n, std::size_t elementBytes) {
-  return std::visit(
+  return common::visit(
       [=](auto &x) { return x.get().Receive(data, n, elementBytes); }, u_);
 }
 
 std::size_t IoStatementState::GetNextInputBytes(const char *&p) {
-  return std::visit([&](auto &x) { return x.get().GetNextInputBytes(p); }, u_);
+  return common::visit(
+      [&](auto &x) { return x.get().GetNextInputBytes(p); }, u_);
 }
 
 bool IoStatementState::AdvanceRecord(int n) {
-  return std::visit([=](auto &x) { return x.get().AdvanceRecord(n); }, u_);
+  return common::visit([=](auto &x) { return x.get().AdvanceRecord(n); }, u_);
 }
 
 void IoStatementState::BackspaceRecord() {
-  std::visit([](auto &x) { x.get().BackspaceRecord(); }, u_);
+  common::visit([](auto &x) { x.get().BackspaceRecord(); }, u_);
 }
 
 void IoStatementState::HandleRelativePosition(std::int64_t n) {
-  std::visit([=](auto &x) { x.get().HandleRelativePosition(n); }, u_);
+  common::visit([=](auto &x) { x.get().HandleRelativePosition(n); }, u_);
 }
 
 void IoStatementState::HandleAbsolutePosition(std::int64_t n) {
-  std::visit([=](auto &x) { x.get().HandleAbsolutePosition(n); }, u_);
+  common::visit([=](auto &x) { x.get().HandleAbsolutePosition(n); }, u_);
 }
 
 void IoStatementState::CompleteOperation() {
-  std::visit([](auto &x) { x.get().CompleteOperation(); }, u_);
+  common::visit([](auto &x) { x.get().CompleteOperation(); }, u_);
 }
 
 int IoStatementState::EndIoStatement() {
-  return std::visit([](auto &x) { return x.get().EndIoStatement(); }, u_);
+  return common::visit([](auto &x) { return x.get().EndIoStatement(); }, u_);
 }
 
 ConnectionState &IoStatementState::GetConnectionState() {
-  return std::visit(
+  return common::visit(
       [](auto &x) -> ConnectionState & { return x.get().GetConnectionState(); },
       u_);
 }
 
 MutableModes &IoStatementState::mutableModes() {
-  return std::visit(
+  return common::visit(
       [](auto &x) -> MutableModes & { return x.get().mutableModes(); }, u_);
 }
 
 bool IoStatementState::BeginReadingRecord() {
-  return std::visit([](auto &x) { return x.get().BeginReadingRecord(); }, u_);
+  return common::visit(
+      [](auto &x) { return x.get().BeginReadingRecord(); }, u_);
 }
 
 IoErrorHandler &IoStatementState::GetIoErrorHandler() const {
-  return std::visit(
+  return common::visit(
       [](auto &x) -> IoErrorHandler & {
         return static_cast<IoErrorHandler &>(x.get());
       },
       u_);
 }
 
 ExternalFileUnit *IoStatementState::GetExternalFileUnit() const {
-  return std::visit([](auto &x) { return x.get().GetExternalFileUnit(); }, u_);
+  return common::visit(
+      [](auto &x) { return x.get().GetExternalFileUnit(); }, u_);
 }
 
 std::optional<char32_t> IoStatementState::GetCurrentChar(
     std::size_t &byteCount) {
   const char *p{nullptr};
   std::size_t bytes{GetNextInputBytes(p)};
   if (bytes == 0) {
     byteCount = 0;
if (GetConnectionState().isUTF8) {
       // Error recovery: return the next byte
     }
     byteCount = 1;
     return *p;
   }
 }
 
 bool IoStatementState::EmitRepeated(char ch, std::size_t n) {
-  return std::visit(
+  return common::visit(
       [=](auto &x) {
         for (std::size_t j{0}; j < n; ++j) {
           if (!x.get().Emit(&ch, 1)) {
             return false;
           }
         }
         return true;
       },
if (auto length{connection.EffectiveRecordLength()}) {
       }
     }
   }
   return false;
 }
 
 bool IoStatementState::Inquire(
     InquiryKeywordHash inquiry, char *out, std::size_t chars) {
-  return std::visit(
+  return common::visit(
       [&](auto &x) { return x.get().Inquire(inquiry, out, chars); }, u_);
 }
 
 bool IoStatementState::Inquire(InquiryKeywordHash inquiry, bool &out) {
-  return std::visit([&](auto &x) { return x.get().Inquire(inquiry, out); }, u_);
+  return common::visit(
+      [&](auto &x) { return x.get().Inquire(inquiry, out); }, u_);
 }
 
 bool IoStatementState::Inquire(
     InquiryKeywordHash inquiry, std::int64_t id, bool &out) {
-  return std::visit(
+  return common::visit(
       [&](auto &x) { return x.get().Inquire(inquiry, id, out); }, u_);
 }
 
 bool IoStatementState::Inquire(InquiryKeywordHash inquiry, std::int64_t &n) {
-  return std::visit([&](auto &x) { return x.get().Inquire(inquiry, n); }, u_);
+  return common::visit(
+      [&](auto &x) { return x.get().Inquire(inquiry, n); }, u_);
 }
 
 void IoStatementState::GotChar(int n) {
   if (auto *formattedIn{
           get_if<FormattedIoStatementState<Direction::Input>>()}) {
     formattedIn->GotChar(n);
   } else {
     GetIoErrorHandler().Crash("IoStatementState::GotChar() called for "