diff --git a/flang/include/flang/Common/indirection.h b/flang/include/flang/Common/indirection.h
index fec3bc7ae8da..a4ef615dc122 100644
--- a/flang/include/flang/Common/indirection.h
+++ b/flang/include/flang/Common/indirection.h
@@ -1,170 +1,170 @@
 //===-- include/flang/Common/indirection.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_INDIRECTION_H_
 #define FORTRAN_COMMON_INDIRECTION_H_
 
 // Define a smart pointer class template that is rather like
 // non-nullable std::unique_ptr<>.  Indirection<> is, like a C++ reference
 // type, restricted to be non-null when constructed or assigned.
 // Indirection<> optionally supports copy construction and copy assignment.
 //
 // To use Indirection<> with forward-referenced types, add
 //    extern template class Fortran::common::Indirection<FORWARD_TYPE>;
 // outside any namespace in a header before use, and
 //    template class Fortran::common::Indirection<FORWARD_TYPE>;
 // in one C++ source file later where a definition of the type is visible.
 
 #include "idioms.h"
 #include <memory>
 #include <type_traits>
 #include <utility>
 
 namespace Fortran::common {
 
 // The default case does not support (deep) copy construction or assignment.
 template <typename A, bool COPY = false> class Indirection {
 public:
   using element_type = A;
   Indirection() = delete;
   Indirection(A *&&p) : p_{p} {
     CHECK(p_ && "assigning null pointer to Indirection");
     p = nullptr;
   }
   Indirection(A &&x) : p_{new A(std::move(x))} {}
   Indirection(Indirection &&that) : p_{that.p_} {
     CHECK(p_ && "move construction of Indirection from null Indirection");
     that.p_ = nullptr;
   }
   ~Indirection() {
     delete p_;
     p_ = nullptr;
   }
   Indirection &operator=(Indirection &&that) {
     CHECK(that.p_ && "move assignment of null Indirection to Indirection");
     auto tmp{p_};
     p_ = that.p_;
     that.p_ = tmp;
     return *this;
   }
 
   A &value() { return *p_; }
   const A &value() const { return *p_; }
 
   bool operator==(const A &that) const { return *p_ == that; }
   bool operator==(const Indirection &that) const { return *p_ == *that.p_; }
 
   template <typename... ARGS>
-  static common::IfNoLvalue<Indirection, ARGS...> Make(ARGS &&... args) {
+  static common::IfNoLvalue<Indirection, ARGS...> Make(ARGS &&...args) {
     return {new A(std::move(args)...)};
   }
 
 private:
   A *p_{nullptr};
 };
 
 // Variant with copy construction and assignment
 template <typename A> class Indirection<A, true> {
 public:
   using element_type = A;
 
   Indirection() = delete;
   Indirection(A *&&p) : p_{p} {
     CHECK(p_ && "assigning null pointer to Indirection");
     p = nullptr;
   }
   Indirection(const A &x) : p_{new A(x)} {}
   Indirection(A &&x) : p_{new A(std::move(x))} {}
   Indirection(const Indirection &that) {
     CHECK(that.p_ && "copy construction of Indirection from null Indirection");
     p_ = new A(*that.p_);
   }
   Indirection(Indirection &&that) : p_{that.p_} {
     CHECK(p_ && "move construction of Indirection from null Indirection");
     that.p_ = nullptr;
   }
   ~Indirection() {
     delete p_;
     p_ = nullptr;
   }
   Indirection &operator=(const Indirection &that) {
     CHECK(that.p_ && "copy assignment of Indirection from null Indirection");
     *p_ = *that.p_;
     return *this;
   }
   Indirection &operator=(Indirection &&that) {
     CHECK(that.p_ && "move assignment of null Indirection to Indirection");
     auto tmp{p_};
     p_ = that.p_;
     that.p_ = tmp;
     return *this;
   }
 
   A &value() { return *p_; }
   const A &value() const { return *p_; }
 
   bool operator==(const A &that) const { return *p_ == that; }
   bool operator==(const Indirection &that) const { return *p_ == *that.p_; }
 
   template <typename... ARGS>
-  static common::IfNoLvalue<Indirection, ARGS...> Make(ARGS &&... args) {
+  static common::IfNoLvalue<Indirection, ARGS...> Make(ARGS &&...args) {
     return {new A(std::move(args)...)};
   }
 
 private:
   A *p_{nullptr};
 };
 
 template <typename A> using CopyableIndirection = Indirection<A, true>;
 
 // A variation of std::unique_ptr<> with a reified deletion routine.
 // Used to avoid dependence cycles between shared libraries.
 template <typename A> class ForwardOwningPointer {
 public:
   ForwardOwningPointer() {}
   ForwardOwningPointer(A *p, void (*del)(A *)) : p_{p}, deleter_{del} {}
   ForwardOwningPointer(ForwardOwningPointer &&that)
       : p_{that.p_}, deleter_{that.deleter_} {
     that.p_ = nullptr;
   }
   ForwardOwningPointer &operator=(ForwardOwningPointer &&that) {
     p_ = that.p_;
     that.p_ = nullptr;
     deleter_ = that.deleter_;
     return *this;
   }
   ~ForwardOwningPointer() {
     if (p_) {
       deleter_(p_);
     }
   }
 
   A &operator*() const { return *p_; }
   A *operator->() const { return p_; }
   operator bool() const { return p_ != nullptr; }
   A *get() { return p_; }
   A *release() {
     A *result{p_};
     p_ = nullptr;
     return result;
   }
 
   void Reset(A *p, void (*del)(A *)) {
     if (p_) {
       deleter_(p_);
     }
     p_ = p;
     deleter_ = del;
   }
 
 private:
   A *p_{nullptr};
   void (*deleter_)(A *){nullptr};
 };
 } // namespace Fortran::common
 #endif // FORTRAN_COMMON_INDIRECTION_H_
diff --git a/flang/include/flang/Common/template.h b/flang/include/flang/Common/template.h
index 866292cfcf48..f31b0afa97fb 100644
--- a/flang/include/flang/Common/template.h
+++ b/flang/include/flang/Common/template.h
@@ -1,323 +1,323 @@
 //===-- include/flang/Common/template.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_TEMPLATE_H_
 #define FORTRAN_COMMON_TEMPLATE_H_
 
 #include "flang/Common/idioms.h"
 #include <functional>
 #include <optional>
 #include <tuple>
 #include <type_traits>
 #include <variant>
 #include <vector>
 
 // Utility templates for metaprogramming and for composing the
 // std::optional<>, std::tuple<>, and std::variant<> containers.
 
 namespace Fortran::common {
 
 // SearchTypeList<PREDICATE, TYPES...> scans a list of types.  The zero-based
 // index of the first type T in the list for which PREDICATE<T>::value() is
 // true is returned, or -1 if the predicate is false for every type in the list.
 // This is a compile-time operation; see SearchTypes below for a run-time form.
 template <int N, template <typename> class PREDICATE, typename TUPLE>
 struct SearchTypeListHelper {
   static constexpr int value() {
     if constexpr (N >= std::tuple_size_v<TUPLE>) {
       return -1;
     } else if constexpr (PREDICATE<std::tuple_element_t<N, TUPLE>>::value()) {
       return N;
     } else {
       return SearchTypeListHelper<N + 1, PREDICATE, TUPLE>::value();
     }
   }
 };
 
 template <template <typename> class PREDICATE, typename... TYPES>
 constexpr int SearchTypeList{
     SearchTypeListHelper<0, PREDICATE, std::tuple<TYPES...>>::value()};
 
 // TypeIndex<A, TYPES...> scans a list of types for simple type equality.
 // The zero-based index of A in the list is returned, or -1 if A is not present.
 template <typename A> struct MatchType {
   template <typename B> struct Match {
     static constexpr bool value() {
       return std::is_same_v<std::decay_t<A>, std::decay_t<B>>;
     }
   };
 };
 
 template <typename A, typename... TYPES>
 constexpr int TypeIndex{SearchTypeList<MatchType<A>::template Match, TYPES...>};
 
 // IsTypeInList<A, TYPES...> is a simple presence predicate.
 template <typename A, typename... TYPES>
 constexpr bool IsTypeInList{TypeIndex<A, TYPES...> >= 0};
 
 // OverMembers extracts the list of types that constitute the alternatives
 // of a std::variant or elements of a std::tuple and passes that list as
 // parameter types to a given variadic template.
 template <template <typename...> class, typename> struct OverMembersHelper;
 template <template <typename...> class T, typename... Ts>
 struct OverMembersHelper<T, std::variant<Ts...>> {
   using type = T<Ts...>;
 };
 template <template <typename...> class T, typename... Ts>
 struct OverMembersHelper<T, std::tuple<Ts...>> {
   using type = T<Ts...>;
 };
 
 template <template <typename...> class T, typename TUPLEorVARIANT>
 using OverMembers =
     typename OverMembersHelper<T, std::decay_t<TUPLEorVARIANT>>::type;
 
 // SearchMembers<PREDICATE> scans the types that constitute the alternatives
 // of a std::variant instantiation or elements of a std::tuple.
 // The zero-based index of the first type T among the alternatives for which
 // PREDICATE<T>::value() is true is returned, or -1 when the predicate is false
 // for every type in the set.
 template <template <typename> class PREDICATE> struct SearchMembersHelper {
   template <typename... Ts> struct Scanner {
     static constexpr int value() { return SearchTypeList<PREDICATE, Ts...>; }
   };
 };
 
 template <template <typename> class PREDICATE, typename TUPLEorVARIANT>
 constexpr int SearchMembers{
     OverMembers<SearchMembersHelper<PREDICATE>::template Scanner,
         TUPLEorVARIANT>::value()};
 
 template <typename A, typename TUPLEorVARIANT>
 constexpr bool HasMember{
     SearchMembers<MatchType<A>::template Match, TUPLEorVARIANT> >= 0};
 
 // std::optional<std::optional<A>> -> std::optional<A>
 template <typename A>
 std::optional<A> JoinOptional(std::optional<std::optional<A>> &&x) {
   if (x) {
     return std::move(*x);
   }
   return std::nullopt;
 }
 
 // Convert an std::optional to an ordinary pointer
 template <typename A> const A *GetPtrFromOptional(const std::optional<A> &x) {
   if (x) {
     return &*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);
 }
 
 // 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(
       [](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>.
 template <typename... TUPLES> struct CombineTuplesHelper {
-  static decltype(auto) f(TUPLES *... a) {
+  static decltype(auto) f(TUPLES *...a) {
     return std::tuple_cat(std::move(*a)...);
   }
   using type = decltype(f(static_cast<TUPLES *>(nullptr)...));
 };
 template <typename... TUPLES>
 using CombineTuples = typename CombineTuplesHelper<TUPLES...>::type;
 
 // CombineVariants takes a list of std::variant<> instantiations and constructs
 // a new instantiation that holds all of their alternatives, which must be
 // pairwise distinct.
 template <typename> struct VariantToTupleHelper;
 template <typename... Ts> struct VariantToTupleHelper<std::variant<Ts...>> {
   using type = std::tuple<Ts...>;
 };
 template <typename VARIANT>
 using VariantToTuple = typename VariantToTupleHelper<VARIANT>::type;
 
 template <typename A, typename... REST> struct AreTypesDistinctHelper {
   static constexpr bool value() {
     if constexpr (sizeof...(REST) > 0) {
       // extra () for clang-format
       return ((... && !std::is_same_v<A, REST>)) &&
           AreTypesDistinctHelper<REST...>::value();
     }
     return true;
   }
 };
 template <typename... Ts>
 constexpr bool AreTypesDistinct{AreTypesDistinctHelper<Ts...>::value()};
 
 template <typename A, typename... Ts> struct AreSameTypeHelper {
   using type = A;
   static constexpr bool value() {
     if constexpr (sizeof...(Ts) == 0) {
       return true;
     } else {
       using Rest = AreSameTypeHelper<Ts...>;
       return std::is_same_v<type, typename Rest::type> && Rest::value();
     }
   }
 };
 
 template <typename... Ts>
 constexpr bool AreSameType{AreSameTypeHelper<Ts...>::value()};
 
 template <typename> struct TupleToVariantHelper;
 template <typename... Ts> struct TupleToVariantHelper<std::tuple<Ts...>> {
   static_assert(AreTypesDistinct<Ts...>,
       "TupleToVariant: types are not pairwise distinct");
   using type = std::variant<Ts...>;
 };
 template <typename TUPLE>
 using TupleToVariant = typename TupleToVariantHelper<TUPLE>::type;
 
 template <typename... VARIANTS> struct CombineVariantsHelper {
   using type = TupleToVariant<CombineTuples<VariantToTuple<VARIANTS>...>>;
 };
 template <typename... VARIANTS>
 using CombineVariants = typename CombineVariantsHelper<VARIANTS...>::type;
 
 // SquashVariantOfVariants: given a std::variant whose alternatives are
 // all std::variant instantiations, form a new union over their alternatives.
 template <typename VARIANT>
 using SquashVariantOfVariants = OverMembers<CombineVariants, VARIANT>;
 
 // Given a type function, MapTemplate applies it to each of the types
 // in a tuple or variant, and collect the results in a given variadic
 // template (typically a std::variant).
 template <template <typename> class, template <typename...> class, typename...>
 struct MapTemplateHelper;
 template <template <typename> class F, template <typename...> class PACKAGE,
     typename... Ts>
 struct MapTemplateHelper<F, PACKAGE, std::tuple<Ts...>> {
   using type = PACKAGE<F<Ts>...>;
 };
 template <template <typename> class F, template <typename...> class PACKAGE,
     typename... Ts>
 struct MapTemplateHelper<F, PACKAGE, std::variant<Ts...>> {
   using type = PACKAGE<F<Ts>...>;
 };
 template <template <typename> class F, typename TUPLEorVARIANT,
     template <typename...> class PACKAGE = std::variant>
 using MapTemplate =
     typename MapTemplateHelper<F, PACKAGE, TUPLEorVARIANT>::type;
 
 // std::tuple<std::optional<>...> -> std::optional<std::tuple<...>>
 // i.e., inverts a tuple of optional values into an optional tuple that has
 // a value only if all of the original elements were present.
 template <typename... A, std::size_t... J>
 std::optional<std::tuple<A...>> AllElementsPresentHelper(
     std::tuple<std::optional<A>...> &&t, std::index_sequence<J...>) {
   bool present[]{std::get<J>(t).has_value()...};
   for (std::size_t j{0}; j < sizeof...(J); ++j) {
     if (!present[j]) {
       return std::nullopt;
     }
   }
   return {std::make_tuple(*std::get<J>(t)...)};
 }
 
 template <typename... A>
 std::optional<std::tuple<A...>> AllElementsPresent(
     std::tuple<std::optional<A>...> &&t) {
   return AllElementsPresentHelper(
       std::move(t), std::index_sequence_for<A...>{});
 }
 
 // std::vector<std::optional<A>> -> std::optional<std::vector<A>>
 // i.e., inverts a vector of optional values into an optional vector that
 // will have a value only when all of the original elements are present.
 template <typename A>
 std::optional<std::vector<A>> AllElementsPresent(
     std::vector<std::optional<A>> &&v) {
   for (const auto &maybeA : v) {
     if (!maybeA) {
       return std::nullopt;
     }
   }
   std::vector<A> result;
   for (auto &&maybeA : std::move(v)) {
     result.emplace_back(std::move(*maybeA));
   }
   return result;
 }
 
 // (std::optional<>...) -> std::optional<std::tuple<...>>
 // i.e., given some number of optional values, return a optional tuple of
 // those values that is present only of all of the values were so.
 template <typename... A>
-std::optional<std::tuple<A...>> AllPresent(std::optional<A> &&... x) {
+std::optional<std::tuple<A...>> AllPresent(std::optional<A> &&...x) {
   return AllElementsPresent(std::make_tuple(std::move(x)...));
 }
 
 // (f(A...) -> R) -> std::optional<A>... -> std::optional<R>
 // Apply a function to optional arguments if all are present.
 // N.B. If the function returns std::optional, MapOptional will return
 // std::optional<std::optional<...>> and you will probably want to
 // run it through JoinOptional to "squash" it.
 template <typename R, typename... A>
 std::optional<R> MapOptional(
-    std::function<R(A &&...)> &&f, std::optional<A> &&... x) {
+    std::function<R(A &&...)> &&f, std::optional<A> &&...x) {
   if (auto args{AllPresent(std::move(x)...)}) {
     return std::make_optional(std::apply(std::move(f), std::move(*args)));
   }
   return std::nullopt;
 }
 template <typename R, typename... A>
-std::optional<R> MapOptional(R (*f)(A &&...), std::optional<A> &&... x) {
+std::optional<R> MapOptional(R (*f)(A &&...), std::optional<A> &&...x) {
   return MapOptional(std::function<R(A && ...)>{f}, std::move(x)...);
 }
 
 // Given a VISITOR class of the general form
 //   struct VISITOR {
 //     using Result = ...;
 //     using Types = std::tuple<...>;
 //     template<typename T> Result Test() { ... }
 //   };
 // SearchTypes will traverse the element types in the tuple in order
 // and invoke VISITOR::Test<T>() on each until it returns a value that
 // casts to true.  If no invocation of Test succeeds, SearchTypes will
 // return a default value.
 template <std::size_t J, typename VISITOR>
 common::IfNoLvalue<typename VISITOR::Result, VISITOR> SearchTypesHelper(
     VISITOR &&visitor, typename VISITOR::Result &&defaultResult) {
   using Tuple = typename VISITOR::Types;
   if constexpr (J < std::tuple_size_v<Tuple>) {
     if (auto result{visitor.template Test<std::tuple_element_t<J, Tuple>>()}) {
       return result;
     }
     return SearchTypesHelper<J + 1, VISITOR>(
         std::move(visitor), std::move(defaultResult));
   } else {
     return std::move(defaultResult);
   }
 }
 
 template <typename VISITOR>
 common::IfNoLvalue<typename VISITOR::Result, VISITOR> SearchTypes(
     VISITOR &&visitor,
     typename VISITOR::Result defaultResult = typename VISITOR::Result{}) {
   return SearchTypesHelper<0, VISITOR>(
       std::move(visitor), std::move(defaultResult));
 }
 } // namespace Fortran::common
 #endif // FORTRAN_COMMON_TEMPLATE_H_
diff --git a/flang/include/flang/Evaluate/expression.h b/flang/include/flang/Evaluate/expression.h
index 3569b68fd9d2..3cb8dd688f76 100644
--- a/flang/include/flang/Evaluate/expression.h
+++ b/flang/include/flang/Evaluate/expression.h
@@ -1,874 +1,874 @@
 //===-- include/flang/Evaluate/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_EVALUATE_EXPRESSION_H_
 #define FORTRAN_EVALUATE_EXPRESSION_H_
 
 // Represent Fortran expressions in a type-safe manner.
 // Expressions are the sole owners of their constituents; i.e., there is no
 // context-independent hash table or sharing of common subexpressions, and
 // thus these are trees, not DAGs.  Both deep copy and move semantics are
 // supported for expression construction.  Expressions may be compared
 // for equality.
 
 #include "common.h"
 #include "constant.h"
 #include "formatting.h"
 #include "type.h"
 #include "variable.h"
 #include "flang/Common/Fortran.h"
 #include "flang/Common/idioms.h"
 #include "flang/Common/indirection.h"
 #include "flang/Common/template.h"
 #include "flang/Parser/char-block.h"
 #include <algorithm>
 #include <list>
 #include <tuple>
 #include <type_traits>
 #include <variant>
 
 namespace llvm {
 class raw_ostream;
 }
 
 namespace Fortran::evaluate {
 
 using common::LogicalOperator;
 using common::RelationalOperator;
 
 // Expressions are represented by specializations of the class template Expr.
 // Each of these specializations wraps a single data member "u" that
 // is a std::variant<> discriminated union over all of the representational
 // types for the constants, variables, operations, and other entities that
 // can be valid expressions in that context:
 // - Expr<Type<CATEGORY, KIND>> represents an expression whose result is of a
 //   specific intrinsic type category and kind, e.g. Type<TypeCategory::Real, 4>
 // - Expr<SomeDerived> wraps data and procedure references that result in an
 //   instance of a derived type (or CLASS(*) unlimited polymorphic)
 // - Expr<SomeKind<CATEGORY>> is a union of Expr<Type<CATEGORY, K>> for each
 //   kind type parameter value K in that intrinsic type category.  It represents
 //   an expression with known category and any kind.
 // - Expr<SomeType> is a union of Expr<SomeKind<CATEGORY>> over the five
 //   intrinsic type categories of Fortran.  It represents any valid expression.
 //
 // Everything that can appear in, or as, a valid Fortran expression must be
 // represented with an instance of some class containing a Result typedef that
 // maps to some instantiation of Type<CATEGORY, KIND>, SomeKind<CATEGORY>,
 // or SomeType.  (Exception: BOZ literal constants in generic Expr<SomeType>.)
 template <typename A> using ResultType = typename std::decay_t<A>::Result;
 
 // Common Expr<> behaviors: every Expr<T> derives from ExpressionBase<T>.
 template <typename RESULT> class ExpressionBase {
 public:
   using Result = RESULT;
 
 private:
   using Derived = Expr<Result>;
 #if defined(__APPLE__) && defined(__GNUC__)
   Derived &derived();
   const Derived &derived() const;
 #else
   Derived &derived() { return *static_cast<Derived *>(this); }
   const Derived &derived() const { return *static_cast<const Derived *>(this); }
 #endif
 
 public:
   template <typename A> Derived &operator=(const A &x) {
     Derived &d{derived()};
     d.u = x;
     return d;
   }
 
   template <typename A> common::IfNoLvalue<Derived &, A> operator=(A &&x) {
     Derived &d{derived()};
     d.u = std::move(x);
     return d;
   }
 
   std::optional<DynamicType> GetType() const;
   int Rank() const;
   std::string AsFortran() const;
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
   static Derived Rewrite(FoldingContext &, Derived &&);
 };
 
 // Operations always have specific Fortran result types (i.e., with known
 // intrinsic type category and kind parameter value).  The classes that
 // represent the operations all inherit from this Operation<> base class
 // template.  Note that Operation has as its first type parameter (DERIVED) a
 // "curiously reoccurring template pattern (CRTP)" reference to the specific
 // operation class being derived from Operation; e.g., Add is defined with
 // struct Add : public Operation<Add, ...>.  Uses of instances of Operation<>,
 // including its own member functions, can access each specific class derived
 // from it via its derived() member function with compile-time type safety.
 template <typename DERIVED, typename RESULT, typename... OPERANDS>
 class Operation {
   // The extra final member is a dummy that allows a safe unused reference
   // to element 1 to arise indirectly in the definition of "right()" below
   // when the operation has but a single operand.
   using OperandTypes = std::tuple<OPERANDS..., std::monostate>;
 
 public:
   using Derived = DERIVED;
   using Result = RESULT;
   static_assert(IsSpecificIntrinsicType<Result>);
   static constexpr std::size_t operands{sizeof...(OPERANDS)};
   template <int J> using Operand = std::tuple_element_t<J, OperandTypes>;
 
   // Unary operations wrap a single Expr with a CopyableIndirection.
   // Binary operations wrap a tuple of CopyableIndirections to Exprs.
 private:
   using Container = std::conditional_t<operands == 1,
       common::CopyableIndirection<Expr<Operand<0>>>,
       std::tuple<common::CopyableIndirection<Expr<OPERANDS>>...>>;
 
 public:
   CLASS_BOILERPLATE(Operation)
-  explicit Operation(const Expr<OPERANDS> &... x) : operand_{x...} {}
-  explicit Operation(Expr<OPERANDS> &&... x) : operand_{std::move(x)...} {}
+  explicit Operation(const Expr<OPERANDS> &...x) : operand_{x...} {}
+  explicit Operation(Expr<OPERANDS> &&...x) : operand_{std::move(x)...} {}
 
   Derived &derived() { return *static_cast<Derived *>(this); }
   const Derived &derived() const { return *static_cast<const Derived *>(this); }
 
   // References to operand expressions from member functions of derived
   // classes for specific operators can be made by index, e.g. operand<0>(),
   // which must be spelled like "this->template operand<0>()" when
   // inherited in a derived class template.  There are convenience aliases
   // left() and right() that are not templates.
   template <int J> Expr<Operand<J>> &operand() {
     if constexpr (operands == 1) {
       static_assert(J == 0);
       return operand_.value();
     } else {
       return std::get<J>(operand_).value();
     }
   }
   template <int J> const Expr<Operand<J>> &operand() const {
     if constexpr (operands == 1) {
       static_assert(J == 0);
       return operand_.value();
     } else {
       return std::get<J>(operand_).value();
     }
   }
 
   Expr<Operand<0>> &left() { return operand<0>(); }
   const Expr<Operand<0>> &left() const { return operand<0>(); }
 
   std::conditional_t<(operands > 1), Expr<Operand<1>> &, void> right() {
     if constexpr (operands > 1) {
       return operand<1>();
     }
   }
   std::conditional_t<(operands > 1), const Expr<Operand<1>> &, void>
   right() const {
     if constexpr (operands > 1) {
       return operand<1>();
     }
   }
 
   static constexpr std::optional<DynamicType> GetType() {
     return Result::GetType();
   }
   int Rank() const {
     int rank{left().Rank()};
     if constexpr (operands > 1) {
       return std::max(rank, right().Rank());
     } else {
       return rank;
     }
   }
 
   bool operator==(const Operation &that) const {
     return operand_ == that.operand_;
   }
 
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   Container operand_;
 };
 
 // Unary operations
 
 // Conversions to specific types from expressions of known category and
 // dynamic kind.
 template <typename TO, TypeCategory FROMCAT = TO::category>
 struct Convert : public Operation<Convert<TO, FROMCAT>, TO, SomeKind<FROMCAT>> {
   // Fortran doesn't have conversions between kinds of CHARACTER apart from
   // assignments, and in those the data must be convertible to/from 7-bit ASCII.
   // Conversions between kinds of COMPLEX are represented piecewise.
   static_assert(((TO::category == TypeCategory::Integer ||
                      TO::category == TypeCategory::Real) &&
                     (FROMCAT == TypeCategory::Integer ||
                         FROMCAT == TypeCategory::Real)) ||
       (TO::category == TypeCategory::Character &&
           FROMCAT == TypeCategory::Character) ||
       (TO::category == TypeCategory::Logical &&
           FROMCAT == TypeCategory::Logical));
   using Result = TO;
   using Operand = SomeKind<FROMCAT>;
   using Base = Operation<Convert, Result, Operand>;
   using Base::Base;
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 };
 
 template <typename A>
 struct Parentheses : public Operation<Parentheses<A>, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Parentheses, A, A>;
   using Base::Base;
 };
 
 template <typename A> struct Negate : public Operation<Negate<A>, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Negate, A, A>;
   using Base::Base;
 };
 
 template <int KIND>
 struct ComplexComponent
     : public Operation<ComplexComponent<KIND>, Type<TypeCategory::Real, KIND>,
           Type<TypeCategory::Complex, KIND>> {
   using Result = Type<TypeCategory::Real, KIND>;
   using Operand = Type<TypeCategory::Complex, KIND>;
   using Base = Operation<ComplexComponent, Result, Operand>;
   CLASS_BOILERPLATE(ComplexComponent)
   ComplexComponent(bool isImaginary, const Expr<Operand> &x)
       : Base{x}, isImaginaryPart{isImaginary} {}
   ComplexComponent(bool isImaginary, Expr<Operand> &&x)
       : Base{std::move(x)}, isImaginaryPart{isImaginary} {}
 
   bool isImaginaryPart{true};
 };
 
 template <int KIND>
 struct Not : public Operation<Not<KIND>, Type<TypeCategory::Logical, KIND>,
                  Type<TypeCategory::Logical, KIND>> {
   using Result = Type<TypeCategory::Logical, KIND>;
   using Operand = Result;
   using Base = Operation<Not, Result, Operand>;
   using Base::Base;
 };
 
 // Character lengths are determined by context in Fortran and do not
 // have explicit syntax for changing them.  Expressions represent
 // changes of length (e.g., for assignments and structure constructors)
 // with this operation.
 template <int KIND>
 struct SetLength
     : public Operation<SetLength<KIND>, Type<TypeCategory::Character, KIND>,
           Type<TypeCategory::Character, KIND>, SubscriptInteger> {
   using Result = Type<TypeCategory::Character, KIND>;
   using CharacterOperand = Result;
   using LengthOperand = SubscriptInteger;
   using Base = Operation<SetLength, Result, CharacterOperand, LengthOperand>;
   using Base::Base;
 };
 
 // Binary operations
 
 template <typename A> struct Add : public Operation<Add<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Add, A, A, A>;
   using Base::Base;
 };
 
 template <typename A> struct Subtract : public Operation<Subtract<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Subtract, A, A, A>;
   using Base::Base;
 };
 
 template <typename A> struct Multiply : public Operation<Multiply<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Multiply, A, A, A>;
   using Base::Base;
 };
 
 template <typename A> struct Divide : public Operation<Divide<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Divide, A, A, A>;
   using Base::Base;
 };
 
 template <typename A> struct Power : public Operation<Power<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Power, A, A, A>;
   using Base::Base;
 };
 
 template <typename A>
 struct RealToIntPower : public Operation<RealToIntPower<A>, A, A, SomeInteger> {
   using Base = Operation<RealToIntPower, A, A, SomeInteger>;
   using Result = A;
   using BaseOperand = A;
   using ExponentOperand = SomeInteger;
   using Base::Base;
 };
 
 template <typename A> struct Extremum : public Operation<Extremum<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Extremum, A, A, A>;
   CLASS_BOILERPLATE(Extremum)
   Extremum(Ordering ord, const Expr<Operand> &x, const Expr<Operand> &y)
       : Base{x, y}, ordering{ord} {}
   Extremum(Ordering ord, Expr<Operand> &&x, Expr<Operand> &&y)
       : Base{std::move(x), std::move(y)}, ordering{ord} {}
   Ordering ordering{Ordering::Greater};
 };
 
 template <int KIND>
 struct ComplexConstructor
     : public Operation<ComplexConstructor<KIND>,
           Type<TypeCategory::Complex, KIND>, Type<TypeCategory::Real, KIND>,
           Type<TypeCategory::Real, KIND>> {
   using Result = Type<TypeCategory::Complex, KIND>;
   using Operand = Type<TypeCategory::Real, KIND>;
   using Base = Operation<ComplexConstructor, Result, Operand, Operand>;
   using Base::Base;
 };
 
 template <int KIND>
 struct Concat
     : public Operation<Concat<KIND>, Type<TypeCategory::Character, KIND>,
           Type<TypeCategory::Character, KIND>,
           Type<TypeCategory::Character, KIND>> {
   using Result = Type<TypeCategory::Character, KIND>;
   using Operand = Result;
   using Base = Operation<Concat, Result, Operand, Operand>;
   using Base::Base;
 };
 
 template <int KIND>
 struct LogicalOperation
     : public Operation<LogicalOperation<KIND>,
           Type<TypeCategory::Logical, KIND>, Type<TypeCategory::Logical, KIND>,
           Type<TypeCategory::Logical, KIND>> {
   using Result = Type<TypeCategory::Logical, KIND>;
   using Operand = Result;
   using Base = Operation<LogicalOperation, Result, Operand, Operand>;
   CLASS_BOILERPLATE(LogicalOperation)
   LogicalOperation(
       LogicalOperator opr, const Expr<Operand> &x, const Expr<Operand> &y)
       : Base{x, y}, logicalOperator{opr} {}
   LogicalOperation(LogicalOperator opr, Expr<Operand> &&x, Expr<Operand> &&y)
       : Base{std::move(x), std::move(y)}, logicalOperator{opr} {}
   LogicalOperator logicalOperator;
 };
 
 // Array constructors
 template <typename RESULT> class ArrayConstructorValues;
 
 struct ImpliedDoIndex {
   using Result = SubscriptInteger;
   bool operator==(const ImpliedDoIndex &) const;
   static constexpr int Rank() { return 0; }
   parser::CharBlock name; // nested implied DOs must use distinct names
 };
 
 template <typename RESULT> class ImpliedDo {
 public:
   using Result = RESULT;
   using Index = ResultType<ImpliedDoIndex>;
   ImpliedDo(parser::CharBlock name, Expr<Index> &&lower, Expr<Index> &&upper,
       Expr<Index> &&stride, ArrayConstructorValues<Result> &&values)
       : name_{name}, lower_{std::move(lower)}, upper_{std::move(upper)},
         stride_{std::move(stride)}, values_{std::move(values)} {}
   DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(ImpliedDo)
   bool operator==(const ImpliedDo &) const;
   parser::CharBlock name() const { return name_; }
   Expr<Index> &lower() { return lower_.value(); }
   const Expr<Index> &lower() const { return lower_.value(); }
   Expr<Index> &upper() { return upper_.value(); }
   const Expr<Index> &upper() const { return upper_.value(); }
   Expr<Index> &stride() { return stride_.value(); }
   const Expr<Index> &stride() const { return stride_.value(); }
   ArrayConstructorValues<Result> &values() { return values_.value(); }
   const ArrayConstructorValues<Result> &values() const {
     return values_.value();
   }
 
 private:
   parser::CharBlock name_;
   common::CopyableIndirection<Expr<Index>> lower_, upper_, stride_;
   common::CopyableIndirection<ArrayConstructorValues<Result>> values_;
 };
 
 template <typename RESULT> struct ArrayConstructorValue {
   using Result = RESULT;
   EVALUATE_UNION_CLASS_BOILERPLATE(ArrayConstructorValue)
   std::variant<Expr<Result>, ImpliedDo<Result>> u;
 };
 
 template <typename RESULT> class ArrayConstructorValues {
 public:
   using Result = RESULT;
   using Values = std::vector<ArrayConstructorValue<Result>>;
   DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(ArrayConstructorValues)
   ArrayConstructorValues() {}
 
   bool operator==(const ArrayConstructorValues &) const;
   static constexpr int Rank() { return 1; }
   template <typename A> common::NoLvalue<A> Push(A &&x) {
     values_.emplace_back(std::move(x));
   }
 
   typename Values::iterator begin() { return values_.begin(); }
   typename Values::const_iterator begin() const { return values_.begin(); }
   typename Values::iterator end() { return values_.end(); }
   typename Values::const_iterator end() const { return values_.end(); }
 
 protected:
   Values values_;
 };
 
 // Note that there are specializations of ArrayConstructor for character
 // and derived types, since they must carry additional type information,
 // but that an empty ArrayConstructor can be constructed for any type
 // given an expression from which such type information may be gleaned.
 template <typename RESULT>
 class ArrayConstructor : public ArrayConstructorValues<RESULT> {
 public:
   using Result = RESULT;
   using Base = ArrayConstructorValues<Result>;
   DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(ArrayConstructor)
   explicit ArrayConstructor(Base &&values) : Base{std::move(values)} {}
   template <typename T> explicit ArrayConstructor(const Expr<T> &) {}
   static constexpr Result result() { return Result{}; }
   static constexpr DynamicType GetType() { return Result::GetType(); }
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 };
 
 template <int KIND>
 class ArrayConstructor<Type<TypeCategory::Character, KIND>>
     : public ArrayConstructorValues<Type<TypeCategory::Character, KIND>> {
 public:
   using Result = Type<TypeCategory::Character, KIND>;
   using Base = ArrayConstructorValues<Result>;
   CLASS_BOILERPLATE(ArrayConstructor)
   ArrayConstructor(Expr<SubscriptInteger> &&len, Base &&v)
       : Base{std::move(v)}, length_{std::move(len)} {}
   template <typename A>
   explicit ArrayConstructor(const A &prototype)
       : length_{prototype.LEN().value()} {}
   bool operator==(const ArrayConstructor &) const;
   static constexpr Result result() { return Result{}; }
   static constexpr DynamicType GetType() { return Result::GetType(); }
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
   const Expr<SubscriptInteger> &LEN() const { return length_.value(); }
 
 private:
   common::CopyableIndirection<Expr<SubscriptInteger>> length_;
 };
 
 template <>
 class ArrayConstructor<SomeDerived>
     : public ArrayConstructorValues<SomeDerived> {
 public:
   using Result = SomeDerived;
   using Base = ArrayConstructorValues<Result>;
   CLASS_BOILERPLATE(ArrayConstructor)
 
   ArrayConstructor(const semantics::DerivedTypeSpec &spec, Base &&v)
       : Base{std::move(v)}, result_{spec} {}
   template <typename A>
   explicit ArrayConstructor(const A &prototype)
       : result_{prototype.GetType().value().GetDerivedTypeSpec()} {}
 
   bool operator==(const ArrayConstructor &) const;
   constexpr Result result() const { return result_; }
   constexpr DynamicType GetType() const { return result_.GetType(); }
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   Result result_;
 };
 
 // Expression representations for each type category.
 
 template <int KIND>
 class Expr<Type<TypeCategory::Integer, KIND>>
     : public ExpressionBase<Type<TypeCategory::Integer, KIND>> {
 public:
   using Result = Type<TypeCategory::Integer, KIND>;
 
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
 
 private:
   using Conversions = std::tuple<Convert<Result, TypeCategory::Integer>,
       Convert<Result, TypeCategory::Real>>;
   using Operations = std::tuple<Parentheses<Result>, Negate<Result>,
       Add<Result>, Subtract<Result>, Multiply<Result>, Divide<Result>,
       Power<Result>, Extremum<Result>>;
   using Indices = std::conditional_t<KIND == ImpliedDoIndex::Result::kind,
       std::tuple<ImpliedDoIndex>, std::tuple<>>;
   using DescriptorInquiries =
       std::conditional_t<KIND == DescriptorInquiry::Result::kind,
           std::tuple<DescriptorInquiry>, std::tuple<>>;
   using Others = std::tuple<Constant<Result>, ArrayConstructor<Result>,
       TypeParamInquiry<KIND>, Designator<Result>, FunctionRef<Result>>;
 
 public:
   common::TupleToVariant<common::CombineTuples<Operations, Conversions, Indices,
       DescriptorInquiries, Others>>
       u;
 };
 
 template <int KIND>
 class Expr<Type<TypeCategory::Real, KIND>>
     : public ExpressionBase<Type<TypeCategory::Real, KIND>> {
 public:
   using Result = Type<TypeCategory::Real, KIND>;
 
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
   explicit Expr(const Scalar<Result> &x) : u{Constant<Result>{x}} {}
 
 private:
   // N.B. Real->Complex and Complex->Real conversions are done with CMPLX
   // and part access operations (resp.).  Conversions between kinds of
   // Complex are done via decomposition to Real and reconstruction.
   using Conversions = std::variant<Convert<Result, TypeCategory::Integer>,
       Convert<Result, TypeCategory::Real>>;
   using Operations = std::variant<ComplexComponent<KIND>, Parentheses<Result>,
       Negate<Result>, Add<Result>, Subtract<Result>, Multiply<Result>,
       Divide<Result>, Power<Result>, RealToIntPower<Result>, Extremum<Result>>;
   using Others = std::variant<Constant<Result>, ArrayConstructor<Result>,
       Designator<Result>, FunctionRef<Result>>;
 
 public:
   common::CombineVariants<Operations, Conversions, Others> u;
 };
 
 template <int KIND>
 class Expr<Type<TypeCategory::Complex, KIND>>
     : public ExpressionBase<Type<TypeCategory::Complex, KIND>> {
 public:
   using Result = Type<TypeCategory::Complex, KIND>;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
   explicit Expr(const Scalar<Result> &x) : u{Constant<Result>{x}} {}
 
   // Note that many COMPLEX operations are represented as REAL operations
   // over their components (viz., conversions, negation, add, and subtract).
   using Operations =
       std::variant<Parentheses<Result>, Multiply<Result>, Divide<Result>,
           Power<Result>, RealToIntPower<Result>, ComplexConstructor<KIND>>;
   using Others = std::variant<Constant<Result>, ArrayConstructor<Result>,
       Designator<Result>, FunctionRef<Result>>;
 
 public:
   common::CombineVariants<Operations, Others> u;
 };
 
 FOR_EACH_INTEGER_KIND(extern template class Expr, )
 FOR_EACH_REAL_KIND(extern template class Expr, )
 FOR_EACH_COMPLEX_KIND(extern template class Expr, )
 
 template <int KIND>
 class Expr<Type<TypeCategory::Character, KIND>>
     : public ExpressionBase<Type<TypeCategory::Character, KIND>> {
 public:
   using Result = Type<TypeCategory::Character, KIND>;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
   explicit Expr(const Scalar<Result> &x) : u{Constant<Result>{x}} {}
   explicit Expr(Scalar<Result> &&x) : u{Constant<Result>{std::move(x)}} {}
 
   std::optional<Expr<SubscriptInteger>> LEN() const;
 
   std::variant<Constant<Result>, ArrayConstructor<Result>, Designator<Result>,
       FunctionRef<Result>, Parentheses<Result>, Convert<Result>, Concat<KIND>,
       Extremum<Result>, SetLength<KIND>>
       u;
 };
 
 FOR_EACH_CHARACTER_KIND(extern template class Expr, )
 
 // The Relational class template is a helper for constructing logical
 // expressions with polymorphism over the cross product of the possible
 // categories and kinds of comparable operands.
 // Fortran defines a numeric relation with distinct types or kinds as
 // first undergoing the same operand conversions that occur with the intrinsic
 // addition operator.  Character relations must have the same kind.
 // There are no relations between LOGICAL values.
 
 template <typename T>
 struct Relational : public Operation<Relational<T>, LogicalResult, T, T> {
   using Result = LogicalResult;
   using Base = Operation<Relational, LogicalResult, T, T>;
   using Operand = typename Base::template Operand<0>;
   static_assert(Operand::category == TypeCategory::Integer ||
       Operand::category == TypeCategory::Real ||
       Operand::category == TypeCategory::Character);
   CLASS_BOILERPLATE(Relational)
   Relational(
       RelationalOperator r, const Expr<Operand> &a, const Expr<Operand> &b)
       : Base{a, b}, opr{r} {}
   Relational(RelationalOperator r, Expr<Operand> &&a, Expr<Operand> &&b)
       : Base{std::move(a), std::move(b)}, opr{r} {}
   RelationalOperator opr;
 };
 
 template <> class Relational<SomeType> {
   // COMPLEX data are compared piecewise.
   using DirectlyComparableTypes =
       common::CombineTuples<IntegerTypes, RealTypes, 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);
   }
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &o) const;
   common::MapTemplate<Relational, DirectlyComparableTypes> u;
 };
 
 FOR_EACH_INTEGER_KIND(extern template struct Relational, )
 FOR_EACH_REAL_KIND(extern template struct Relational, )
 FOR_EACH_CHARACTER_KIND(extern template struct Relational, )
 extern template struct Relational<SomeType>;
 
 // Logical expressions of a kind bigger than LogicalResult
 // do not include Relational<> operations as possibilities,
 // since the results of Relationals are always LogicalResult
 // (kind=1).
 template <int KIND>
 class Expr<Type<TypeCategory::Logical, KIND>>
     : public ExpressionBase<Type<TypeCategory::Logical, KIND>> {
 public:
   using Result = Type<TypeCategory::Logical, KIND>;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
   explicit Expr(const Scalar<Result> &x) : u{Constant<Result>{x}} {}
   explicit Expr(bool x) : u{Constant<Result>{x}} {}
 
 private:
   using Operations = std::tuple<Convert<Result>, Parentheses<Result>, Not<KIND>,
       LogicalOperation<KIND>>;
   using Relations = std::conditional_t<KIND == LogicalResult::kind,
       std::tuple<Relational<SomeType>>, std::tuple<>>;
   using Others = std::tuple<Constant<Result>, ArrayConstructor<Result>,
       Designator<Result>, FunctionRef<Result>>;
 
 public:
   common::TupleToVariant<common::CombineTuples<Operations, Relations, Others>>
       u;
 };
 
 FOR_EACH_LOGICAL_KIND(extern template class Expr, )
 
 // StructureConstructor pairs a StructureConstructorValues instance
 // (a map associating symbols with expressions) with a derived type
 // specification.  There are two other similar classes:
 //  - ArrayConstructor<SomeDerived> comprises a derived type spec &
 //    zero or more instances of Expr<SomeDerived>; it has rank 1
 //    but not (in the most general case) a known shape.
 //  - Constant<SomeDerived> comprises a derived type spec, zero or more
 //    homogeneous instances of StructureConstructorValues whose type
 //    parameters and component expressions are all constant, and a
 //    known shape (possibly scalar).
 // StructureConstructor represents a scalar value of derived type that
 // is not necessarily a constant.  It is used only as an Expr<SomeDerived>
 // alternative and as the type Scalar<SomeDerived> (with an assumption
 // of constant component value expressions).
 class StructureConstructor {
 public:
   using Result = SomeDerived;
 
   explicit StructureConstructor(const semantics::DerivedTypeSpec &spec)
       : result_{spec} {}
   StructureConstructor(
       const semantics::DerivedTypeSpec &, const StructureConstructorValues &);
   StructureConstructor(
       const semantics::DerivedTypeSpec &, StructureConstructorValues &&);
   CLASS_BOILERPLATE(StructureConstructor)
 
   constexpr Result result() const { return result_; }
   const semantics::DerivedTypeSpec &derivedTypeSpec() const {
     return result_.derivedTypeSpec();
   }
   StructureConstructorValues &values() { return values_; }
   const StructureConstructorValues &values() const { return values_; }
 
   bool operator==(const StructureConstructor &) const;
 
   StructureConstructorValues::iterator begin() { return values_.begin(); }
   StructureConstructorValues::const_iterator begin() const {
     return values_.begin();
   }
   StructureConstructorValues::iterator end() { return values_.end(); }
   StructureConstructorValues::const_iterator end() const {
     return values_.end();
   }
 
   const Expr<SomeType> *Find(const Symbol &) const; // can return null
 
   StructureConstructor &Add(const semantics::Symbol &, Expr<SomeType> &&);
   int Rank() const { return 0; }
   DynamicType GetType() const;
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   Result result_;
   StructureConstructorValues values_;
 };
 
 // An expression whose result has a derived type.
 template <> class Expr<SomeDerived> : public ExpressionBase<SomeDerived> {
 public:
   using Result = SomeDerived;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
   std::variant<Constant<Result>, ArrayConstructor<Result>, StructureConstructor,
       Designator<Result>, FunctionRef<Result>>
       u;
 };
 
 // A polymorphic expression of known intrinsic type category, but dynamic
 // kind, represented as a discriminated union over Expr<Type<CAT, K>>
 // for each supported kind K in the category.
 template <TypeCategory CAT>
 class Expr<SomeKind<CAT>> : public ExpressionBase<SomeKind<CAT>> {
 public:
   using Result = SomeKind<CAT>;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
   int GetKind() const;
   common::MapTemplate<Expr, CategoryTypes<CAT>> u;
 };
 
 template <> class Expr<SomeCharacter> : public ExpressionBase<SomeCharacter> {
 public:
   using Result = SomeCharacter;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
   int GetKind() const;
   std::optional<Expr<SubscriptInteger>> LEN() const;
   common::MapTemplate<Expr, CategoryTypes<TypeCategory::Character>> u;
 };
 
 // A variant comprising the Expr<> instantiations over SomeDerived and
 // SomeKind<CATEGORY>.
 using CategoryExpression = common::MapTemplate<Expr, SomeCategory>;
 
 // BOZ literal "typeless" constants must be wide enough to hold a numeric
 // value of any supported kind of INTEGER or REAL.  They must also be
 // distinguishable from other integer constants, since they are permitted
 // to be used in only a few situations.
 using BOZLiteralConstant = typename LargestReal::Scalar::Word;
 
 // Null pointers without MOLD= arguments are typed by context.
 struct NullPointer {
   constexpr bool operator==(const NullPointer &) const { return true; }
   constexpr int Rank() const { return 0; }
 };
 
 // Procedure pointer targets are treated as if they were typeless.
 // They are either procedure designators or values returned from
 // references to functions that return procedure (not object) pointers.
 using TypelessExpression = std::variant<BOZLiteralConstant, NullPointer,
     ProcedureDesignator, ProcedureRef>;
 
 // A completely generic expression, polymorphic across all of the intrinsic type
 // categories and each of their kinds.
 template <> class Expr<SomeType> : public ExpressionBase<SomeType> {
 public:
   using Result = SomeType;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
 
   // Owning references to these generic expressions can appear in other
   // compiler data structures (viz., the parse tree and symbol table), so
   // its destructor is externalized to reduce redundant default instances.
   ~Expr();
 
   template <TypeCategory CAT, int KIND>
   explicit Expr(const Expr<Type<CAT, KIND>> &x) : u{Expr<SomeKind<CAT>>{x}} {}
 
   template <TypeCategory CAT, int KIND>
   explicit Expr(Expr<Type<CAT, KIND>> &&x)
       : u{Expr<SomeKind<CAT>>{std::move(x)}} {}
 
   template <TypeCategory CAT, int KIND>
   Expr &operator=(const Expr<Type<CAT, KIND>> &x) {
     u = Expr<SomeKind<CAT>>{x};
     return *this;
   }
 
   template <TypeCategory CAT, int KIND>
   Expr &operator=(Expr<Type<CAT, KIND>> &&x) {
     u = Expr<SomeKind<CAT>>{std::move(x)};
     return *this;
   }
 
 public:
   common::CombineVariants<TypelessExpression, CategoryExpression> u;
 };
 
 // An assignment is either intrinsic, user-defined (with a ProcedureRef to
 // specify the procedure to call), or pointer assignment (with possibly empty
 // BoundsSpec or non-empty BoundsRemapping). In all cases there are Exprs
 // representing the LHS and RHS of the assignment.
 class Assignment {
 public:
   Assignment(Expr<SomeType> &&lhs, Expr<SomeType> &&rhs)
       : lhs(std::move(lhs)), rhs(std::move(rhs)) {}
 
   struct Intrinsic {};
   using BoundsSpec = std::vector<Expr<SubscriptInteger>>;
   using BoundsRemapping =
       std::vector<std::pair<Expr<SubscriptInteger>, Expr<SubscriptInteger>>>;
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
   Expr<SomeType> lhs;
   Expr<SomeType> rhs;
   std::variant<Intrinsic, ProcedureRef, BoundsSpec, BoundsRemapping> u;
 };
 
 // This wrapper class is used, by means of a forward reference with
 // an owning pointer, to cache analyzed expressions in parse tree nodes.
 struct GenericExprWrapper {
   GenericExprWrapper() {}
   explicit GenericExprWrapper(std::optional<Expr<SomeType>> &&x)
       : v{std::move(x)} {}
   ~GenericExprWrapper();
   static void Deleter(GenericExprWrapper *);
   std::optional<Expr<SomeType>> v; // vacant if error
 };
 
 // Like GenericExprWrapper but for analyzed assignments
 struct GenericAssignmentWrapper {
   GenericAssignmentWrapper() {}
   explicit GenericAssignmentWrapper(Assignment &&x) : v{std::move(x)} {}
   ~GenericAssignmentWrapper();
   static void Deleter(GenericAssignmentWrapper *);
   std::optional<Assignment> v; // vacant if error
 };
 
 FOR_EACH_CATEGORY_TYPE(extern template class Expr, )
 FOR_EACH_TYPE_AND_KIND(extern template class ExpressionBase, )
 FOR_EACH_INTRINSIC_KIND(extern template class ArrayConstructorValues, )
 FOR_EACH_INTRINSIC_KIND(extern template class ArrayConstructor, )
 
 // Template instantiations to resolve these "extern template" declarations.
 #define INSTANTIATE_EXPRESSION_TEMPLATES \
   FOR_EACH_INTRINSIC_KIND(template class Expr, ) \
   FOR_EACH_CATEGORY_TYPE(template class Expr, ) \
   FOR_EACH_INTEGER_KIND(template struct Relational, ) \
   FOR_EACH_REAL_KIND(template struct Relational, ) \
   FOR_EACH_CHARACTER_KIND(template struct Relational, ) \
   template struct Relational<SomeType>; \
   FOR_EACH_TYPE_AND_KIND(template class ExpressionBase, ) \
   FOR_EACH_INTRINSIC_KIND(template class ArrayConstructorValues, ) \
   FOR_EACH_INTRINSIC_KIND(template class ArrayConstructor, )
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_EXPRESSION_H_
diff --git a/flang/include/flang/Evaluate/tools.h b/flang/include/flang/Evaluate/tools.h
index e64aaece15bf..081795208b13 100644
--- a/flang/include/flang/Evaluate/tools.h
+++ b/flang/include/flang/Evaluate/tools.h
@@ -1,922 +1,922 @@
 //===-- include/flang/Evaluate/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_EVALUATE_TOOLS_H_
 #define FORTRAN_EVALUATE_TOOLS_H_
 
 #include "traverse.h"
 #include "flang/Common/idioms.h"
 #include "flang/Common/template.h"
 #include "flang/Common/unwrap.h"
 #include "flang/Evaluate/constant.h"
 #include "flang/Evaluate/expression.h"
 #include "flang/Parser/message.h"
 #include "flang/Semantics/attr.h"
 #include "flang/Semantics/symbol.h"
 #include <array>
 #include <optional>
 #include <set>
 #include <type_traits>
 #include <utility>
 
 namespace Fortran::evaluate {
 
 // Some expression predicates and extractors.
 
 // Predicate: true when an expression is a variable reference, not an
 // operation.  Be advised: a call to a function that returns an object
 // pointer is a "variable" in Fortran (it can be the left-hand side of
 // an assignment).
 struct IsVariableHelper
     : public AnyTraverse<IsVariableHelper, std::optional<bool>> {
   using Result = std::optional<bool>; // effectively tri-state
   using Base = AnyTraverse<IsVariableHelper, Result>;
   IsVariableHelper() : Base{*this} {}
   using Base::operator();
   Result operator()(const StaticDataObject &) const { return false; }
   Result operator()(const Symbol &) const;
   Result operator()(const Component &) const;
   Result operator()(const ArrayRef &) const;
   Result operator()(const Substring &) const;
   Result operator()(const CoarrayRef &) const { return true; }
   Result operator()(const ComplexPart &) const { return true; }
   Result operator()(const ProcedureDesignator &) const;
   template <typename T> Result operator()(const Expr<T> &x) const {
     if constexpr (common::HasMember<T, AllIntrinsicTypes> ||
         std::is_same_v<T, SomeDerived>) {
       // Expression with a specific type
       if (std::holds_alternative<Designator<T>>(x.u) ||
           std::holds_alternative<FunctionRef<T>>(x.u)) {
         if (auto known{(*this)(x.u)}) {
           return known;
         }
       }
       return false;
     } else {
       return (*this)(x.u);
     }
   }
 };
 
 template <typename A> bool IsVariable(const A &x) {
   if (auto known{IsVariableHelper{}(x)}) {
     return *known;
   } else {
     return false;
   }
 }
 
 // Predicate: true when an expression is assumed-rank
 bool IsAssumedRank(const Symbol &);
 bool IsAssumedRank(const ActualArgument &);
 template <typename A> bool IsAssumedRank(const A &) { return false; }
 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);
 }
 template <typename A> bool IsAssumedRank(const std::optional<A> &x) {
   return x && IsAssumedRank(*x);
 }
 
 // Generalizing packagers: these take operations and expressions of more
 // specific types and wrap them in Expr<> containers of more abstract types.
 
 template <typename A> common::IfNoLvalue<Expr<ResultType<A>>, A> AsExpr(A &&x) {
   return Expr<ResultType<A>>{std::move(x)};
 }
 
 template <typename T> Expr<T> AsExpr(Expr<T> &&x) {
   static_assert(IsSpecificIntrinsicType<T>);
   return std::move(x);
 }
 
 template <TypeCategory CATEGORY>
 Expr<SomeKind<CATEGORY>> AsCategoryExpr(Expr<SomeKind<CATEGORY>> &&x) {
   return std::move(x);
 }
 
 template <typename A>
 common::IfNoLvalue<Expr<SomeType>, A> AsGenericExpr(A &&x) {
   if constexpr (common::HasMember<A, TypelessExpression>) {
     return Expr<SomeType>{std::move(x)};
   } else {
     return Expr<SomeType>{AsCategoryExpr(std::move(x))};
   }
 }
 
 template <typename A>
 common::IfNoLvalue<Expr<SomeKind<ResultType<A>::category>>, A> AsCategoryExpr(
     A &&x) {
   return Expr<SomeKind<ResultType<A>::category>>{AsExpr(std::move(x))};
 }
 
 inline Expr<SomeType> AsGenericExpr(Expr<SomeType> &&x) { return std::move(x); }
 
 Expr<SomeType> Parenthesize(Expr<SomeType> &&);
 
 Expr<SomeReal> GetComplexPart(
     const Expr<SomeComplex> &, bool isImaginary = false);
 
 template <int KIND>
 Expr<SomeComplex> MakeComplex(Expr<Type<TypeCategory::Real, KIND>> &&re,
     Expr<Type<TypeCategory::Real, KIND>> &&im) {
   return AsCategoryExpr(ComplexConstructor<KIND>{std::move(re), std::move(im)});
 }
 
 template <typename A> constexpr bool IsNumericCategoryExpr() {
   if constexpr (common::HasMember<A, TypelessExpression>) {
     return false;
   } else {
     return common::HasMember<ResultType<A>, NumericCategoryTypes>;
   }
 }
 
 // Specializing extractor.  If an Expr wraps some type of object, perhaps
 // in several layers, return a pointer to it; otherwise null.  Also works
 // with expressions contained in ActualArgument.
 template <typename A, typename B>
 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);
   } 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 nullptr;
 }
 
 template <typename A, typename B>
 const A *UnwrapExpr(const std::optional<B> &x) {
   if (x) {
     return UnwrapExpr<A>(*x);
   } else {
     return nullptr;
   }
 }
 
 template <typename A, typename B> A *UnwrapExpr(std::optional<B> &x) {
   if (x) {
     return UnwrapExpr<A>(*x);
   } else {
     return nullptr;
   }
 }
 
 // If an expression simply wraps a DataRef, extract and return it.
 // The Boolean argument controls the handling of Substring
 // references: when true (not default), it extracts the base DataRef
 // of a substring, if it has one.
 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(
       [=](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(
       [=](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 {
     return std::nullopt;
   }
 }
 std::optional<DataRef> ExtractSubstringBase(const Substring &);
 
 // Predicate: is an expression is an array element reference?
 template <typename T>
 bool IsArrayElement(const Expr<T> &expr, bool intoSubstring = false) {
   if (auto dataRef{ExtractDataRef(expr, intoSubstring)}) {
     const DataRef *ref{&*dataRef};
     while (const Component * component{std::get_if<Component>(&ref->u)}) {
       ref = &component->base();
     }
     return std::holds_alternative<ArrayRef>(ref->u);
   } else {
     return false;
   }
 }
 
 template <typename A>
 std::optional<NamedEntity> ExtractNamedEntity(const A &x) {
   if (auto dataRef{ExtractDataRef(x, true)}) {
     return std::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> {
               return co.GetBase();
             },
             [](auto &&) { return std::optional<NamedEntity>{}; },
         },
         std::move(dataRef->u));
   } else {
     return std::nullopt;
   }
 }
 
 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);
   }
   std::optional<CoarrayRef> operator()(const DataRef &dataRef) const {
     return std::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;
     }
   }
   std::optional<CoarrayRef> operator()(const ProcedureDesignator &des) const {
     if (const auto *component{
             std::get_if<common::CopyableIndirection<Component>>(&des.u)}) {
       return (*this)(component->value());
     } else {
       return std::nullopt;
     }
   }
   std::optional<CoarrayRef> operator()(const Component &component) const {
     return (*this)(component.base());
   }
   std::optional<CoarrayRef> operator()(const ArrayRef &arrayRef) const {
     return (*this)(arrayRef.base());
   }
 };
 
 template <typename A> std::optional<CoarrayRef> ExtractCoarrayRef(const A &x) {
   if (auto dataRef{ExtractDataRef(x, true)}) {
     return ExtractCoindexedObjectHelper{}(*dataRef);
   } else {
     return ExtractCoindexedObjectHelper{}(x);
   }
 }
 
 // If an expression is simply a whole symbol data designator,
 // extract and return that symbol, else null.
 template <typename A> const Symbol *UnwrapWholeSymbolDataRef(const A &x) {
   if (auto dataRef{ExtractDataRef(x)}) {
     if (const SymbolRef * p{std::get_if<SymbolRef>(&dataRef->u)}) {
       return &p->get();
     }
   }
   return nullptr;
 }
 
 // GetFirstSymbol(A%B%C[I]%D) -> A
 template <typename A> const Symbol *GetFirstSymbol(const A &x) {
   if (auto dataRef{ExtractDataRef(x, true)}) {
     return &dataRef->GetFirstSymbol();
   } else {
     return nullptr;
   }
 }
 
 // Creation of conversion expressions can be done to either a known
 // specific intrinsic type with ConvertToType<T>(x) or by converting
 // one arbitrary expression to the type of another with ConvertTo(to, from).
 
 template <typename TO, TypeCategory FROMCAT>
 Expr<TO> ConvertToType(Expr<SomeKind<FROMCAT>> &&x) {
   static_assert(IsSpecificIntrinsicType<TO>);
   if constexpr (FROMCAT != TO::category) {
     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(
           [&](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 {
       return Expr<TO>{Convert<TO, FROMCAT>{std::move(x)}};
     }
   } else {
     // Same type category
     if (auto *already{std::get_if<Expr<TO>>(&x.u)}) {
       return std::move(*already);
     }
     if constexpr (TO::category == TypeCategory::Complex) {
       // Extract, convert, and recombine the components.
       return Expr<TO>{std::visit(
           [](auto &z) {
             using FromType = ResultType<decltype(z)>;
             using FromPart = typename FromType::Part;
             using FromGeneric = SomeKind<TypeCategory::Real>;
             using ToPart = typename TO::Part;
             Convert<ToPart, TypeCategory::Real> re{Expr<FromGeneric>{
                 Expr<FromPart>{ComplexComponent<FromType::kind>{false, z}}}};
             Convert<ToPart, TypeCategory::Real> im{Expr<FromGeneric>{
                 Expr<FromPart>{ComplexComponent<FromType::kind>{true, z}}}};
             return ComplexConstructor<TO::kind>{
                 AsExpr(std::move(re)), AsExpr(std::move(im))};
           },
           x.u)};
     } else {
       return Expr<TO>{Convert<TO, TO::category>{std::move(x)}};
     }
   }
 }
 
 template <typename TO, TypeCategory FROMCAT, int FROMKIND>
 Expr<TO> ConvertToType(Expr<Type<FROMCAT, FROMKIND>> &&x) {
   return ConvertToType<TO, FROMCAT>(Expr<SomeKind<FROMCAT>>{std::move(x)});
 }
 
 template <typename TO> Expr<TO> ConvertToType(BOZLiteralConstant &&x) {
   static_assert(IsSpecificIntrinsicType<TO>);
   if constexpr (TO::category == TypeCategory::Integer) {
     return Expr<TO>{
         Constant<TO>{Scalar<TO>::ConvertUnsigned(std::move(x)).value}};
   } else {
     static_assert(TO::category == TypeCategory::Real);
     using Word = typename Scalar<TO>::Word;
     return Expr<TO>{
         Constant<TO>{Scalar<TO>{Word::ConvertUnsigned(std::move(x)).value}}};
   }
 }
 
 // Conversions to dynamic types
 std::optional<Expr<SomeType>> ConvertToType(
     const DynamicType &, Expr<SomeType> &&);
 std::optional<Expr<SomeType>> ConvertToType(
     const DynamicType &, std::optional<Expr<SomeType>> &&);
 std::optional<Expr<SomeType>> ConvertToType(const Symbol &, Expr<SomeType> &&);
 std::optional<Expr<SomeType>> ConvertToType(
     const Symbol &, std::optional<Expr<SomeType>> &&);
 
 // Conversions to the type of another expression
 template <TypeCategory TC, int TK, typename FROM>
 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(
       [&](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(
       [&](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).
 template <TypeCategory TOCAT, typename VALUE> struct ConvertToKindHelper {
   using Result = std::optional<Expr<SomeKind<TOCAT>>>;
   using Types = CategoryTypes<TOCAT>;
   ConvertToKindHelper(int k, VALUE &&x) : kind{k}, value{std::move(x)} {}
   template <typename T> Result Test() {
     if (kind == T::kind) {
       return std::make_optional(
           AsCategoryExpr(ConvertToType<T>(std::move(value))));
     }
     return std::nullopt;
   }
   int kind;
   VALUE value;
 };
 
 template <TypeCategory TOCAT, typename VALUE>
 common::IfNoLvalue<Expr<SomeKind<TOCAT>>, VALUE> ConvertToKind(
     int kind, VALUE &&x) {
   return common::SearchTypes(
       ConvertToKindHelper<TOCAT, VALUE>{kind, std::move(x)})
       .value();
 }
 
 // Given a type category CAT, SameKindExprs<CAT, N> is a variant that
 // holds an arrays of expressions of the same supported kind in that
 // category.
 template <typename A, int N = 2> using SameExprs = std::array<Expr<A>, N>;
 template <int N = 2> struct SameKindExprsHelper {
   template <typename A> using SameExprs = std::array<Expr<A>, N>;
 };
 template <TypeCategory CAT, int N = 2>
 using SameKindExprs =
     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(
       [&](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 {
           return {SameExprs<XTy>{std::move(kx), ConvertTo(kx, std::move(ky))}};
         }
 #if !__clang__ && 100 * __GNUC__ + __GNUC_MINOR__ == 801
         // Silence a bogus warning about a missing return with G++ 8.1.0.
         // Doesn't execute, but must be correctly typed.
         CHECK(!"can't happen");
         return {SameExprs<XTy>{std::move(kx), std::move(kx)}};
 #endif
       },
       std::move(x.u), std::move(y.u));
 }
 
 // Ensure that both operands of an intrinsic REAL operation (or CMPLX()
 // constructor) are INTEGER or REAL, then convert them as necessary to the
 // same kind of REAL.
 using ConvertRealOperandsResult =
     std::optional<SameKindExprs<TypeCategory::Real, 2>>;
 ConvertRealOperandsResult ConvertRealOperands(parser::ContextualMessages &,
     Expr<SomeType> &&, Expr<SomeType> &&, int defaultRealKind);
 
 // Per F'2018 R718, if both components are INTEGER, they are both converted
 // to default REAL and the result is default COMPLEX.  Otherwise, the
 // kind of the result is the kind of most precise REAL component, and the other
 // component is converted if necessary to its type.
 std::optional<Expr<SomeComplex>> ConstructComplex(parser::ContextualMessages &,
     Expr<SomeType> &&, Expr<SomeType> &&, int defaultRealKind);
 std::optional<Expr<SomeComplex>> ConstructComplex(parser::ContextualMessages &,
     std::optional<Expr<SomeType>> &&, std::optional<Expr<SomeType>> &&,
     int defaultRealKind);
 
 template <typename A> Expr<TypeOf<A>> ScalarConstantToExpr(const A &x) {
   using Ty = TypeOf<A>;
   static_assert(
       std::is_same_v<Scalar<Ty>, std::decay_t<A>>, "TypeOf<> is broken");
   return Expr<TypeOf<A>>{Constant<Ty>{x}};
 }
 
 // Combine two expressions of the same specific numeric type with an operation
 // to produce a new expression.  Implements piecewise addition and subtraction
 // for COMPLEX.
 template <template <typename> class OPR, typename SPECIFIC>
 Expr<SPECIFIC> Combine(Expr<SPECIFIC> &&x, Expr<SPECIFIC> &&y) {
   static_assert(IsSpecificIntrinsicType<SPECIFIC>);
   if constexpr (SPECIFIC::category == TypeCategory::Complex &&
       (std::is_same_v<OPR<LargestReal>, Add<LargestReal>> ||
           std::is_same_v<OPR<LargestReal>, Subtract<LargestReal>>)) {
     static constexpr int kind{SPECIFIC::kind};
     using Part = Type<TypeCategory::Real, kind>;
     return AsExpr(ComplexConstructor<kind>{
         AsExpr(OPR<Part>{AsExpr(ComplexComponent<kind>{false, x}),
             AsExpr(ComplexComponent<kind>{false, y})}),
         AsExpr(OPR<Part>{AsExpr(ComplexComponent<kind>{true, x}),
             AsExpr(ComplexComponent<kind>{true, y})})});
   } else {
     return AsExpr(OPR<SPECIFIC>{std::move(x), std::move(y)});
   }
 }
 
 // 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(
       [](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)));
 }
 
 // Given two expressions of arbitrary type, try to combine them with a
 // binary numeric operation (e.g., Add), possibly with data type conversion of
 // one of the operands to the type of the other.  Handles special cases with
 // typeless literal operands and with REAL/COMPLEX exponentiation to INTEGER
 // powers.
 template <template <typename> class OPR>
 std::optional<Expr<SomeType>> NumericOperation(parser::ContextualMessages &,
     Expr<SomeType> &&, Expr<SomeType> &&, int defaultRealKind);
 
 extern template std::optional<Expr<SomeType>> NumericOperation<Power>(
     parser::ContextualMessages &, Expr<SomeType> &&, Expr<SomeType> &&,
     int defaultRealKind);
 extern template std::optional<Expr<SomeType>> NumericOperation<Multiply>(
     parser::ContextualMessages &, Expr<SomeType> &&, Expr<SomeType> &&,
     int defaultRealKind);
 extern template std::optional<Expr<SomeType>> NumericOperation<Divide>(
     parser::ContextualMessages &, Expr<SomeType> &&, Expr<SomeType> &&,
     int defaultRealKind);
 extern template std::optional<Expr<SomeType>> NumericOperation<Add>(
     parser::ContextualMessages &, Expr<SomeType> &&, Expr<SomeType> &&,
     int defaultRealKind);
 extern template std::optional<Expr<SomeType>> NumericOperation<Subtract>(
     parser::ContextualMessages &, Expr<SomeType> &&, Expr<SomeType> &&,
     int defaultRealKind);
 
 std::optional<Expr<SomeType>> Negation(
     parser::ContextualMessages &, Expr<SomeType> &&);
 
 // Given two expressions of arbitrary type, try to combine them with a
 // relational operator (e.g., .LT.), possibly with data type conversion.
 std::optional<Expr<LogicalResult>> Relate(parser::ContextualMessages &,
     RelationalOperator, Expr<SomeType> &&, Expr<SomeType> &&);
 
 template <int K>
 Expr<Type<TypeCategory::Logical, K>> LogicalNegation(
     Expr<Type<TypeCategory::Logical, K>> &&x) {
   return AsExpr(Not<K>{std::move(x)});
 }
 
 Expr<SomeLogical> LogicalNegation(Expr<SomeLogical> &&);
 
 template <int K>
 Expr<Type<TypeCategory::Logical, K>> BinaryLogicalOperation(LogicalOperator opr,
     Expr<Type<TypeCategory::Logical, K>> &&x,
     Expr<Type<TypeCategory::Logical, K>> &&y) {
   return AsExpr(LogicalOperation<K>{opr, std::move(x), std::move(y)});
 }
 
 Expr<SomeLogical> BinaryLogicalOperation(
     LogicalOperator, Expr<SomeLogical> &&, Expr<SomeLogical> &&);
 
 // Convenience functions and operator overloadings for expression construction.
 // These interfaces are defined only for those situations that can never
 // emit any message.  Use the more general templates (above) in other
 // situations.
 
 template <TypeCategory C, int K>
 Expr<Type<C, K>> operator-(Expr<Type<C, K>> &&x) {
   return AsExpr(Negate<Type<C, K>>{std::move(x)});
 }
 
 template <int K>
 Expr<Type<TypeCategory::Complex, K>> operator-(
     Expr<Type<TypeCategory::Complex, K>> &&x) {
   using Part = Type<TypeCategory::Real, K>;
   return AsExpr(ComplexConstructor<K>{
       AsExpr(Negate<Part>{AsExpr(ComplexComponent<K>{false, x})}),
       AsExpr(Negate<Part>{AsExpr(ComplexComponent<K>{true, x})})});
 }
 
 template <TypeCategory C, int K>
 Expr<Type<C, K>> operator+(Expr<Type<C, K>> &&x, Expr<Type<C, K>> &&y) {
   return AsExpr(Combine<Add, Type<C, K>>(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<Subtract, Type<C, K>>(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<Multiply, Type<C, K>>(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(
       [](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 <TypeCategory CAT>
 Expr<SomeKind<CAT>> operator-(
     Expr<SomeKind<CAT>> &&x, Expr<SomeKind<CAT>> &&y) {
   return PromoteAndCombine<Subtract, CAT>(std::move(x), std::move(y));
 }
 
 template <TypeCategory CAT>
 Expr<SomeKind<CAT>> operator*(
     Expr<SomeKind<CAT>> &&x, Expr<SomeKind<CAT>> &&y) {
   return PromoteAndCombine<Multiply, CAT>(std::move(x), std::move(y));
 }
 
 template <TypeCategory CAT>
 Expr<SomeKind<CAT>> operator/(
     Expr<SomeKind<CAT>> &&x, Expr<SomeKind<CAT>> &&y) {
   return PromoteAndCombine<Divide, CAT>(std::move(x), std::move(y));
 }
 
 // A utility for use with common::SearchTypes to create generic expressions
 // when an intrinsic type category for (say) a variable is known
 // but the kind parameter value is not.
 template <TypeCategory CAT, template <typename> class TEMPLATE, typename VALUE>
 struct TypeKindVisitor {
   using Result = std::optional<Expr<SomeType>>;
   using Types = CategoryTypes<CAT>;
 
   TypeKindVisitor(int k, VALUE &&x) : kind{k}, value{std::move(x)} {}
   TypeKindVisitor(int k, const VALUE &x) : kind{k}, value{x} {}
 
   template <typename T> Result Test() {
     if (kind == T::kind) {
       return AsGenericExpr(TEMPLATE<T>{std::move(value)});
     }
     return std::nullopt;
   }
 
   int kind;
   VALUE value;
 };
 
 // TypedWrapper() wraps a object in an explicitly typed representation
 // (e.g., Designator<> or FunctionRef<>) that has been instantiated on
 // a dynamically chosen Fortran type.
 template <TypeCategory CATEGORY, template <typename> typename WRAPPER,
     typename WRAPPED>
 common::IfNoLvalue<std::optional<Expr<SomeType>>, WRAPPED> WrapperHelper(
     int kind, WRAPPED &&x) {
   return common::SearchTypes(
       TypeKindVisitor<CATEGORY, WRAPPER, WRAPPED>{kind, std::move(x)});
 }
 
 template <template <typename> typename WRAPPER, typename WRAPPED>
 common::IfNoLvalue<std::optional<Expr<SomeType>>, WRAPPED> TypedWrapper(
     const DynamicType &dyType, WRAPPED &&x) {
   switch (dyType.category()) {
     SWITCH_COVERS_ALL_CASES
   case TypeCategory::Integer:
     return WrapperHelper<TypeCategory::Integer, WRAPPER, WRAPPED>(
         dyType.kind(), std::move(x));
   case TypeCategory::Real:
     return WrapperHelper<TypeCategory::Real, WRAPPER, WRAPPED>(
         dyType.kind(), std::move(x));
   case TypeCategory::Complex:
     return WrapperHelper<TypeCategory::Complex, WRAPPER, WRAPPED>(
         dyType.kind(), std::move(x));
   case TypeCategory::Character:
     return WrapperHelper<TypeCategory::Character, WRAPPER, WRAPPED>(
         dyType.kind(), std::move(x));
   case TypeCategory::Logical:
     return WrapperHelper<TypeCategory::Logical, WRAPPER, WRAPPED>(
         dyType.kind(), std::move(x));
   case TypeCategory::Derived:
     return AsGenericExpr(Expr<SomeDerived>{WRAPPER<SomeDerived>{std::move(x)}});
   }
 }
 
 // GetLastSymbol() returns the rightmost symbol in an object or procedure
 // designator (which has perhaps been wrapped in an Expr<>), or a null pointer
 // when none is found.
 struct GetLastSymbolHelper
     : public AnyTraverse<GetLastSymbolHelper, std::optional<const Symbol *>> {
   using Result = std::optional<const Symbol *>;
   using Base = AnyTraverse<GetLastSymbolHelper, Result>;
   GetLastSymbolHelper() : Base{*this} {}
   using Base::operator();
   Result operator()(const Symbol &x) const { return &x; }
   Result operator()(const Component &x) const { return &x.GetLastSymbol(); }
   Result operator()(const NamedEntity &x) const { return &x.GetLastSymbol(); }
   Result operator()(const ProcedureDesignator &x) const {
     return x.GetSymbol();
   }
   template <typename T> Result operator()(const Expr<T> &x) const {
     if constexpr (common::HasMember<T, AllIntrinsicTypes> ||
         std::is_same_v<T, SomeDerived>) {
       if (const auto *designator{std::get_if<Designator<T>>(&x.u)}) {
         if (auto known{(*this)(*designator)}) {
           return known;
         }
       }
       return nullptr;
     } else {
       return (*this)(x.u);
     }
   }
 };
 
 template <typename A> const Symbol *GetLastSymbol(const A &x) {
   if (auto known{GetLastSymbolHelper{}(x)}) {
     return *known;
   } else {
     return nullptr;
   }
 }
 
 // Convenience: If GetLastSymbol() succeeds on the argument, return its
 // set of attributes, otherwise the empty set.
 template <typename A> semantics::Attrs GetAttrs(const A &x) {
   if (const Symbol * symbol{GetLastSymbol(x)}) {
     return symbol->attrs();
   } else {
     return {};
   }
 }
 
 // GetBaseObject()
 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);
 }
 template <typename A>
 std::optional<BaseObject> GetBaseObject(const std::optional<A> &x) {
   if (x) {
     return GetBaseObject(*x);
   } else {
     return std::nullopt;
   }
 }
 
 // Predicate: IsAllocatableOrPointer()
 template <typename A> bool IsAllocatableOrPointer(const A &x) {
   return GetAttrs(x).HasAny(
       semantics::Attrs{semantics::Attr::POINTER, semantics::Attr::ALLOCATABLE});
 }
 
 // Procedure and pointer detection predicates
 bool IsProcedure(const Expr<SomeType> &);
 bool IsProcedurePointer(const Expr<SomeType> &);
 bool IsNullPointer(const Expr<SomeType> &);
 
 // Extracts the chain of symbols from a designator, which has perhaps been
 // wrapped in an Expr<>, removing all of the (co)subscripts.  The
 // base object will be the first symbol in the result vector.
 struct GetSymbolVectorHelper
     : public Traverse<GetSymbolVectorHelper, SymbolVector> {
   using Result = SymbolVector;
   using Base = Traverse<GetSymbolVectorHelper, Result>;
   using Base::operator();
   GetSymbolVectorHelper() : Base{*this} {}
   Result Default() { return {}; }
   Result Combine(Result &&a, Result &&b) {
     a.insert(a.end(), b.begin(), b.end());
     return std::move(a);
   }
   Result operator()(const Symbol &) const;
   Result operator()(const Component &) const;
   Result operator()(const ArrayRef &) const;
   Result operator()(const CoarrayRef &) const;
 };
 template <typename A> SymbolVector GetSymbolVector(const A &x) {
   return GetSymbolVectorHelper{}(x);
 }
 
 // GetLastTarget() returns the rightmost symbol in an object designator's
 // SymbolVector that has the POINTER or TARGET attribute, or a null pointer
 // when none is found.
 const Symbol *GetLastTarget(const SymbolVector &);
 
 // Resolves any whole ASSOCIATE(B=>A) associations, then returns GetUltimate()
 const Symbol &ResolveAssociations(const Symbol &);
 
 // Collects all of the Symbols in an expression
 template <typename A> semantics::SymbolSet CollectSymbols(const A &);
 extern template semantics::SymbolSet CollectSymbols(const Expr<SomeType> &);
 extern template semantics::SymbolSet CollectSymbols(const Expr<SomeInteger> &);
 extern template semantics::SymbolSet CollectSymbols(
     const Expr<SubscriptInteger> &);
 
 // Predicate: does a variable contain a vector-valued subscript (not a triplet)?
 bool HasVectorSubscript(const Expr<SomeType> &);
 
 // Utilities for attaching the location of the declaration of a symbol
 // of interest to a message, if both pointers are non-null.  Handles
 // the case of USE association gracefully.
 parser::Message *AttachDeclaration(parser::Message &, const Symbol &);
 parser::Message *AttachDeclaration(parser::Message *, const Symbol &);
 template <typename MESSAGES, typename... A>
 parser::Message *SayWithDeclaration(
-    MESSAGES &messages, const Symbol &symbol, A &&... x) {
+    MESSAGES &messages, const Symbol &symbol, A &&...x) {
   return AttachDeclaration(messages.Say(std::forward<A>(x)...), symbol);
 }
 
 // Check for references to impure procedures; returns the name
 // of one to complain about, if any exist.
 std::optional<std::string> FindImpureCall(
     const IntrinsicProcTable &, const Expr<SomeType> &);
 std::optional<std::string> FindImpureCall(
     const IntrinsicProcTable &, const ProcedureRef &);
 
 // Predicate: is a scalar expression suitable for naive scalar expansion
 // in the flattening of an array expression?
 // TODO: capture such scalar expansions in temporaries, flatten everything
 struct UnexpandabilityFindingVisitor
     : public AnyTraverse<UnexpandabilityFindingVisitor> {
   using Base = AnyTraverse<UnexpandabilityFindingVisitor>;
   using Base::operator();
   UnexpandabilityFindingVisitor() : Base{*this} {}
   template <typename T> bool operator()(const FunctionRef<T> &) { return true; }
   bool operator()(const CoarrayRef &) { return true; }
 };
 
 template <typename T> bool IsExpandableScalar(const Expr<T> &expr) {
   return !UnexpandabilityFindingVisitor{}(expr);
 }
 
 } // namespace Fortran::evaluate
 
 namespace Fortran::semantics {
 
 class Scope;
 
 // These functions are used in Evaluate so they are defined here rather than in
 // Semantics to avoid a link-time dependency on Semantics.
 
 bool IsVariableName(const Symbol &);
 bool IsPureProcedure(const Symbol &);
 bool IsPureProcedure(const Scope &);
 bool IsFunction(const Symbol &);
 bool IsProcedure(const Symbol &);
 bool IsProcedurePointer(const Symbol &);
 bool IsSaved(const Symbol &); // saved implicitly or explicitly
 bool IsDummy(const Symbol &);
 bool IsFunctionResult(const Symbol &);
 
 // Follow use, host, and construct assocations to a variable, if any.
 const Symbol *GetAssociationRoot(const Symbol &);
 const Symbol *FindCommonBlockContaining(const Symbol &);
 int CountLenParameters(const DerivedTypeSpec &);
 int CountNonConstantLenParameters(const DerivedTypeSpec &);
 const Symbol &GetUsedModule(const UseDetails &);
 
 } // namespace Fortran::semantics
 
 #endif // FORTRAN_EVALUATE_TOOLS_H_
diff --git a/flang/include/flang/Evaluate/traverse.h b/flang/include/flang/Evaluate/traverse.h
index 4888946c1a6c..a81f511d9dfa 100644
--- a/flang/include/flang/Evaluate/traverse.h
+++ b/flang/include/flang/Evaluate/traverse.h
@@ -1,308 +1,308 @@
 //===-- include/flang/Evaluate/traverse.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_EVALUATE_TRAVERSE_H_
 #define FORTRAN_EVALUATE_TRAVERSE_H_
 
 // A utility for scanning all of the constituent objects in an Expr<>
 // expression representation using a collection of mutually recursive
 // functions to compose a function object.
 //
 // The class template Traverse<> below implements a function object that
 // can handle every type that can appear in or around an Expr<>.
 // Each of its overloads for operator() should be viewed as a *default*
 // handler; some of these must be overridden by the client to accomplish
 // its particular task.
 //
 // The client (Visitor) of Traverse<Visitor,Result> must define:
 // - a member function "Result Default();"
 // - a member function "Result Combine(Result &&, Result &&)"
 // - overrides for "Result operator()"
 //
 // Boilerplate classes also appear below to ease construction of visitors.
 // See CheckSpecificationExpr() in check-expression.cpp for an example client.
 //
 // How this works:
 // - The operator() overloads in Traverse<> invoke the visitor's Default() for
 //   expression leaf nodes.  They invoke the visitor's operator() for the
 //   subtrees of interior nodes, and the visitor's Combine() to merge their
 //   results together.
 // - Overloads of operator() in each visitor handle the cases of interest.
 
 #include "expression.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/type.h"
 #include <set>
 #include <type_traits>
 
 namespace Fortran::evaluate {
 template <typename Visitor, typename Result> class Traverse {
 public:
   explicit Traverse(Visitor &v) : visitor_{v} {}
 
   // Packaging
   template <typename A, bool C>
   Result operator()(const common::Indirection<A, C> &x) const {
     return visitor_(x.value());
   }
   template <typename A> Result operator()(SymbolRef x) const {
     return visitor_(*x);
   }
   template <typename A> Result operator()(const std::unique_ptr<A> &x) const {
     return visitor_(x.get());
   }
   template <typename A> Result operator()(const std::shared_ptr<A> &x) const {
     return visitor_(x.get());
   }
   template <typename A> Result operator()(const A *x) const {
     if (x) {
       return visitor_(*x);
     } else {
       return visitor_.Default();
     }
   }
   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);
   }
   template <typename A> Result operator()(const std::vector<A> &x) const {
     return CombineContents(x);
   }
 
   // Leaves
   Result operator()(const BOZLiteralConstant &) const {
     return visitor_.Default();
   }
   Result operator()(const NullPointer &) const { return visitor_.Default(); }
   template <typename T> Result operator()(const Constant<T> &x) const {
     if constexpr (T::category == TypeCategory::Derived) {
       std::optional<Result> result;
       for (const StructureConstructorValues &map : x.values()) {
         for (const auto &pair : map) {
           auto value{visitor_(pair.second.value())};
           result = result
               ? visitor_.Combine(std::move(*result), std::move(value))
               : std::move(value);
         }
       }
       return result ? *result : visitor_.Default();
     } else {
       return visitor_.Default();
     }
   }
   Result operator()(const Symbol &) const { return visitor_.Default(); }
   Result operator()(const StaticDataObject &) const {
     return visitor_.Default();
   }
   Result operator()(const ImpliedDoIndex &) const { return visitor_.Default(); }
 
   // Variables
   Result operator()(const BaseObject &x) const { return visitor_(x.u); }
   Result operator()(const Component &x) const {
     return Combine(x.base(), x.GetLastSymbol());
   }
   Result operator()(const NamedEntity &x) const {
     if (const Component * component{x.UnwrapComponent()}) {
       return visitor_(*component);
     } else {
       return visitor_(x.GetFirstSymbol());
     }
   }
   template <int KIND> Result operator()(const TypeParamInquiry<KIND> &x) const {
     return visitor_(x.base());
   }
   Result operator()(const Triplet &x) const {
     return Combine(x.lower(), x.upper(), x.stride());
   }
   Result operator()(const Subscript &x) const { return visitor_(x.u); }
   Result operator()(const ArrayRef &x) const {
     return Combine(x.base(), x.subscript());
   }
   Result operator()(const CoarrayRef &x) const {
     return Combine(
         x.base(), x.subscript(), x.cosubscript(), x.stat(), x.team());
   }
   Result operator()(const DataRef &x) const { return visitor_(x.u); }
   Result operator()(const Substring &x) const {
     return Combine(x.parent(), x.lower(), x.upper());
   }
   Result operator()(const ComplexPart &x) const {
     return visitor_(x.complex());
   }
   template <typename T> Result operator()(const Designator<T> &x) const {
     return visitor_(x.u);
   }
   template <typename T> Result operator()(const Variable<T> &x) const {
     return visitor_(x.u);
   }
   Result operator()(const DescriptorInquiry &x) const {
     return visitor_(x.base());
   }
 
   // Calls
   Result operator()(const SpecificIntrinsic &) const {
     return visitor_.Default();
   }
   Result operator()(const ProcedureDesignator &x) const {
     if (const Component * component{x.GetComponent()}) {
       return visitor_(*component);
     } else if (const Symbol * symbol{x.GetSymbol()}) {
       return visitor_(*symbol);
     } else {
       return visitor_(DEREF(x.GetSpecificIntrinsic()));
     }
   }
   Result operator()(const ActualArgument &x) const {
     if (const auto *symbol{x.GetAssumedTypeDummy()}) {
       return visitor_(*symbol);
     } else {
       return visitor_(x.UnwrapExpr());
     }
   }
   Result operator()(const ProcedureRef &x) const {
     return Combine(x.proc(), x.arguments());
   }
   template <typename T> Result operator()(const FunctionRef<T> &x) const {
     return visitor_(static_cast<const ProcedureRef &>(x));
   }
 
   // Other primaries
   template <typename T>
   Result operator()(const ArrayConstructorValue<T> &x) const {
     return visitor_(x.u);
   }
   template <typename T>
   Result operator()(const ArrayConstructorValues<T> &x) const {
     return CombineContents(x);
   }
   template <typename T> Result operator()(const ImpliedDo<T> &x) const {
     return Combine(x.lower(), x.upper(), x.stride(), x.values());
   }
   Result operator()(const semantics::ParamValue &x) const {
     return visitor_(x.GetExplicit());
   }
   Result operator()(
       const semantics::DerivedTypeSpec::ParameterMapType::value_type &x) const {
     return visitor_(x.second);
   }
   Result operator()(const semantics::DerivedTypeSpec &x) const {
     return CombineContents(x.parameters());
   }
   Result operator()(const StructureConstructorValues::value_type &x) const {
     return visitor_(x.second);
   }
   Result operator()(const StructureConstructor &x) const {
     return visitor_.Combine(visitor_(x.derivedTypeSpec()), CombineContents(x));
   }
 
   // Operations and wrappers
   template <typename D, typename R, typename O>
   Result operator()(const Operation<D, R, O> &op) const {
     return visitor_(op.left());
   }
   template <typename D, typename R, typename LO, typename RO>
   Result operator()(const Operation<D, R, LO, RO> &op) const {
     return Combine(op.left(), op.right());
   }
   Result operator()(const Relational<SomeType> &x) const {
     return visitor_(x.u);
   }
   template <typename T> Result operator()(const Expr<T> &x) const {
     return visitor_(x.u);
   }
 
 private:
   template <typename ITER> Result CombineRange(ITER iter, ITER end) const {
     if (iter == end) {
       return visitor_.Default();
     } else {
       Result result{visitor_(*iter++)};
       for (; iter != end; ++iter) {
         result = visitor_.Combine(std::move(result), visitor_(*iter));
       }
       return result;
     }
   }
 
   template <typename A> Result CombineContents(const A &x) const {
     return CombineRange(x.begin(), x.end());
   }
 
   template <typename A, typename... Bs>
-  Result Combine(const A &x, const Bs &... ys) const {
+  Result Combine(const A &x, const Bs &...ys) const {
     if constexpr (sizeof...(Bs) == 0) {
       return visitor_(x);
     } else {
       return visitor_.Combine(visitor_(x), Combine(ys...));
     }
   }
 
   Visitor &visitor_;
 };
 
 // For validity checks across an expression: if any operator() result is
 // false, so is the overall result.
 template <typename Visitor, bool DefaultValue,
     typename Base = Traverse<Visitor, bool>>
 struct AllTraverse : public Base {
   explicit AllTraverse(Visitor &v) : Base{v} {}
   using Base::operator();
   static bool Default() { return DefaultValue; }
   static bool Combine(bool x, bool y) { return x && y; }
 };
 
 // For searches over an expression: the first operator() result that
 // is truthful is the final result.  Works for Booleans, pointers,
 // and std::optional<>.
 template <typename Visitor, typename Result = bool,
     typename Base = Traverse<Visitor, Result>>
 class AnyTraverse : public Base {
 public:
   explicit AnyTraverse(Visitor &v) : Base{v} {}
   using Base::operator();
   Result Default() const { return default_; }
   static Result Combine(Result &&x, Result &&y) {
     if (x) {
       return std::move(x);
     } else {
       return std::move(y);
     }
   }
 
 private:
   Result default_{};
 };
 
 template <typename Visitor, typename Set,
     typename Base = Traverse<Visitor, Set>>
 struct SetTraverse : public Base {
   explicit SetTraverse(Visitor &v) : Base{v} {}
   using Base::operator();
   static Set Default() { return {}; }
   static Set Combine(Set &&x, Set &&y) {
 #if defined __GNUC__ && !defined __APPLE__ && !(CLANG_LIBRARIES)
     x.merge(y);
 #else
     // std::set::merge() not available (yet)
     for (auto &value : y) {
       x.insert(std::move(value));
     }
 #endif
     return std::move(x);
   }
 };
 
 } // namespace Fortran::evaluate
 #endif
diff --git a/flang/include/flang/Parser/message.h b/flang/include/flang/Parser/message.h
index 84106dbc3bfc..46a72e08a237 100644
--- a/flang/include/flang/Parser/message.h
+++ b/flang/include/flang/Parser/message.h
@@ -1,318 +1,318 @@
 //===-- include/flang/Parser/message.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_MESSAGE_H_
 #define FORTRAN_PARSER_MESSAGE_H_
 
 // Defines a representation for sequences of compiler messages.
 // Supports nested contextualization.
 
 #include "char-block.h"
 #include "char-set.h"
 #include "provenance.h"
 #include "flang/Common/idioms.h"
 #include "flang/Common/reference-counted.h"
 #include "flang/Common/restorer.h"
 #include <cstddef>
 #include <cstring>
 #include <forward_list>
 #include <optional>
 #include <string>
 #include <utility>
 #include <variant>
 
 namespace Fortran::parser {
 
 // Use "..."_err_en_US and "..."_en_US literals to define the static
 // text and fatality of a message.
 class MessageFixedText {
 public:
   constexpr MessageFixedText(
       const char str[], std::size_t n, bool isFatal = false)
       : text_{str, n}, isFatal_{isFatal} {}
   constexpr MessageFixedText(const MessageFixedText &) = default;
   constexpr MessageFixedText(MessageFixedText &&) = default;
   constexpr MessageFixedText &operator=(const MessageFixedText &) = default;
   constexpr MessageFixedText &operator=(MessageFixedText &&) = default;
 
   CharBlock text() const { return text_; }
   bool isFatal() const { return isFatal_; }
 
 private:
   CharBlock text_;
   bool isFatal_{false};
 };
 
 inline namespace literals {
 constexpr MessageFixedText operator""_en_US(const char str[], std::size_t n) {
   return MessageFixedText{str, n, false /* not fatal */};
 }
 
 constexpr MessageFixedText operator""_err_en_US(
     const char str[], std::size_t n) {
   return MessageFixedText{str, n, true /* fatal */};
 }
 } // namespace literals
 
 // The construction of a MessageFormattedText uses a MessageFixedText
 // as a vsnprintf() formatting string that is applied to the
 // following arguments.  CharBlock and std::string argument
 // values are also supported; they are automatically converted into
 // char pointers that are suitable for '%s' formatting.
 class MessageFormattedText {
 public:
   template <typename... A>
-  MessageFormattedText(const MessageFixedText &text, A &&... x)
+  MessageFormattedText(const MessageFixedText &text, A &&...x)
       : isFatal_{text.isFatal()} {
     Format(&text, Convert(std::forward<A>(x))...);
   }
   MessageFormattedText(const MessageFormattedText &) = default;
   MessageFormattedText(MessageFormattedText &&) = default;
   MessageFormattedText &operator=(const MessageFormattedText &) = default;
   MessageFormattedText &operator=(MessageFormattedText &&) = default;
   const std::string &string() const { return string_; }
   bool isFatal() const { return isFatal_; }
   std::string MoveString() { return std::move(string_); }
 
 private:
   void Format(const MessageFixedText *, ...);
 
   template <typename A> A Convert(const A &x) {
     static_assert(!std::is_class_v<std::decay_t<A>>);
     return x;
   }
   template <typename A> A Convert(A &x) {
     static_assert(!std::is_class_v<std::decay_t<A>>);
     return x;
   }
   template <typename A> common::IfNoLvalue<A, A> Convert(A &&x) {
     static_assert(!std::is_class_v<std::decay_t<A>>);
     return std::move(x);
   }
   const char *Convert(const char *s) { return s; }
   const char *Convert(char *s) { return s; }
   const char *Convert(const std::string &);
   const char *Convert(std::string &);
   const char *Convert(std::string &&);
   const char *Convert(CharBlock);
   std::intmax_t Convert(std::int64_t x) { return x; }
   std::uintmax_t Convert(std::uint64_t x) { return x; }
 
   bool isFatal_{false};
   std::string string_;
   std::forward_list<std::string> conversions_; // preserves created strings
 };
 
 // Represents a formatted rendition of "expected '%s'"_err_en_US
 // on a constant text or a set of characters.
 class MessageExpectedText {
 public:
   MessageExpectedText(const char *s, std::size_t n) {
     if (n == std::string::npos) {
       n = std::strlen(s);
     }
     if (n == 1) {
       // Treat a one-character string as a singleton set for better merging.
       u_ = SetOfChars{*s};
     } else {
       u_ = CharBlock{s, n};
     }
   }
   constexpr explicit MessageExpectedText(CharBlock cb) : u_{cb} {}
   constexpr explicit MessageExpectedText(char ch) : u_{SetOfChars{ch}} {}
   constexpr explicit MessageExpectedText(SetOfChars set) : u_{set} {}
   MessageExpectedText(const MessageExpectedText &) = default;
   MessageExpectedText(MessageExpectedText &&) = default;
   MessageExpectedText &operator=(const MessageExpectedText &) = default;
   MessageExpectedText &operator=(MessageExpectedText &&) = default;
 
   std::string ToString() const;
   bool Merge(const MessageExpectedText &);
 
 private:
   std::variant<CharBlock, SetOfChars> u_;
 };
 
 class Message : public common::ReferenceCounted<Message> {
 public:
   using Reference = common::CountedReference<Message>;
 
   Message(const Message &) = default;
   Message(Message &&) = default;
   Message &operator=(const Message &) = default;
   Message &operator=(Message &&) = default;
 
   Message(ProvenanceRange pr, const MessageFixedText &t)
       : location_{pr}, text_{t} {}
   Message(ProvenanceRange pr, const MessageFormattedText &s)
       : location_{pr}, text_{s} {}
   Message(ProvenanceRange pr, MessageFormattedText &&s)
       : location_{pr}, text_{std::move(s)} {}
   Message(ProvenanceRange pr, const MessageExpectedText &t)
       : location_{pr}, text_{t} {}
 
   Message(CharBlock csr, const MessageFixedText &t)
       : location_{csr}, text_{t} {}
   Message(CharBlock csr, const MessageFormattedText &s)
       : location_{csr}, text_{s} {}
   Message(CharBlock csr, MessageFormattedText &&s)
       : location_{csr}, text_{std::move(s)} {}
   Message(CharBlock csr, const MessageExpectedText &t)
       : location_{csr}, text_{t} {}
 
   template <typename RANGE, typename A, typename... As>
-  Message(RANGE r, const MessageFixedText &t, A &&x, As &&... xs)
+  Message(RANGE r, const MessageFixedText &t, A &&x, As &&...xs)
       : location_{r}, text_{MessageFormattedText{
                           t, std::forward<A>(x), std::forward<As>(xs)...}} {}
 
   bool attachmentIsContext() const { return attachmentIsContext_; }
   Reference attachment() const { return attachment_; }
 
   void SetContext(Message *c) {
     attachment_ = c;
     attachmentIsContext_ = true;
   }
   Message &Attach(Message *);
   Message &Attach(std::unique_ptr<Message> &&);
-  template <typename... A> Message &Attach(A &&... args) {
+  template <typename... A> Message &Attach(A &&...args) {
     return Attach(new Message{std::forward<A>(args)...}); // reference-counted
   }
 
   bool SortBefore(const Message &that) const;
   bool IsFatal() const;
   std::string ToString() const;
   std::optional<ProvenanceRange> GetProvenanceRange(const CookedSource &) const;
   void Emit(llvm::raw_ostream &, const CookedSource &,
       bool echoSourceLine = true) const;
 
   // If this Message or any of its attachments locates itself via a CharBlock
   // within a particular CookedSource, replace its location with the
   // corresponding ProvenanceRange.
   void ResolveProvenances(const CookedSource &);
 
   bool IsMergeable() const {
     return std::holds_alternative<MessageExpectedText>(text_);
   }
   bool Merge(const Message &);
 
 private:
   bool AtSameLocation(const Message &) const;
 
   std::variant<ProvenanceRange, CharBlock> location_;
   std::variant<MessageFixedText, MessageFormattedText, MessageExpectedText>
       text_;
   bool attachmentIsContext_{false};
   Reference attachment_;
 };
 
 class Messages {
 public:
   Messages() {}
   Messages(Messages &&that) : messages_{std::move(that.messages_)} {
     if (!messages_.empty()) {
       last_ = that.last_;
       that.ResetLastPointer();
     }
   }
   Messages &operator=(Messages &&that) {
     messages_ = std::move(that.messages_);
     if (messages_.empty()) {
       ResetLastPointer();
     } else {
       last_ = that.last_;
       that.ResetLastPointer();
     }
     return *this;
   }
 
   std::forward_list<Message> &messages() { return messages_; }
   bool empty() const { return messages_.empty(); }
   void clear();
 
-  template <typename... A> Message &Say(A &&... args) {
+  template <typename... A> Message &Say(A &&...args) {
     last_ = messages_.emplace_after(last_, std::forward<A>(args)...);
     return *last_;
   }
 
   void Annex(Messages &&that) {
     if (!that.messages_.empty()) {
       messages_.splice_after(last_, that.messages_);
       last_ = that.last_;
       that.ResetLastPointer();
     }
   }
 
   void Restore(Messages &&that) {
     that.Annex(std::move(*this));
     *this = std::move(that);
   }
 
   bool Merge(const Message &);
   void Merge(Messages &&);
   void Copy(const Messages &);
   void ResolveProvenances(const CookedSource &);
   void Emit(llvm::raw_ostream &, const CookedSource &cooked,
       bool echoSourceLines = true) const;
   void AttachTo(Message &);
   bool AnyFatalError() const;
 
 private:
   void ResetLastPointer() { last_ = messages_.before_begin(); }
 
   std::forward_list<Message> messages_;
   std::forward_list<Message>::iterator last_{messages_.before_begin()};
 };
 
 class ContextualMessages {
 public:
   ContextualMessages() = default;
   ContextualMessages(CharBlock at, Messages *m) : at_{at}, messages_{m} {}
   explicit ContextualMessages(Messages *m) : messages_{m} {}
   ContextualMessages(const ContextualMessages &that)
       : at_{that.at_}, messages_{that.messages_} {}
 
   CharBlock at() const { return at_; }
   Messages *messages() const { return messages_; }
   bool empty() const { return !messages_ || messages_->empty(); }
 
   // Set CharBlock for messages; restore when the returned value is deleted
   common::Restorer<CharBlock> SetLocation(CharBlock at) {
     if (at.empty()) {
       at = at_;
     }
     return common::ScopedSet(at_, std::move(at));
   }
 
   // Diverts messages to another buffer; restored when the returned
   // value is deleted.
   common::Restorer<Messages *> SetMessages(Messages &buffer) {
     return common::ScopedSet(messages_, &buffer);
   }
   // Discard messages; destination restored when the returned value is deleted.
   common::Restorer<Messages *> DiscardMessages() {
     return common::ScopedSet(messages_, nullptr);
   }
 
-  template <typename... A> Message *Say(CharBlock at, A &&... args) {
+  template <typename... A> Message *Say(CharBlock at, A &&...args) {
     if (messages_ != nullptr) {
       return &messages_->Say(at, std::forward<A>(args)...);
     } else {
       return nullptr;
     }
   }
 
-  template <typename... A> Message *Say(A &&... args) {
+  template <typename... A> Message *Say(A &&...args) {
     return Say(at_, std::forward<A>(args)...);
   }
 
 private:
   CharBlock at_;
   Messages *messages_{nullptr};
 };
 } // namespace Fortran::parser
 #endif // FORTRAN_PARSER_MESSAGE_H_
diff --git a/flang/include/flang/Parser/parse-state.h b/flang/include/flang/Parser/parse-state.h
index c704d6a9ad1b..5d96e95e4da7 100644
--- a/flang/include/flang/Parser/parse-state.h
+++ b/flang/include/flang/Parser/parse-state.h
@@ -1,233 +1,232 @@
 //===-- include/flang/Parser/parse-state.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_STATE_H_
 #define FORTRAN_PARSER_PARSE_STATE_H_
 
 // Defines the ParseState type used as the argument for every parser's
 // Parse member or static function.  Tracks source provenance, context,
 // accumulated messages, and an arbitrary UserState instance for parsing
 // attempts.  Must be efficient to duplicate and assign for backtracking
 // and recovery during parsing!
 
 #include "user-state.h"
 #include "flang/Common/Fortran-features.h"
 #include "flang/Common/idioms.h"
 #include "flang/Parser/characters.h"
 #include "flang/Parser/message.h"
 #include "flang/Parser/provenance.h"
 #include <cstddef>
 #include <cstring>
 #include <list>
 #include <memory>
 #include <optional>
 #include <utility>
 
 namespace Fortran::parser {
 
 using common::LanguageFeature;
 
 class ParseState {
 public:
   // TODO: Add a constructor for parsing a normalized module file.
   ParseState(const CookedSource &cooked)
       : p_{&cooked.data().front()}, limit_{&cooked.data().back() + 1} {}
   ParseState(const ParseState &that)
       : p_{that.p_}, limit_{that.limit_}, context_{that.context_},
         userState_{that.userState_}, inFixedForm_{that.inFixedForm_},
         anyErrorRecovery_{that.anyErrorRecovery_},
         anyConformanceViolation_{that.anyConformanceViolation_},
         deferMessages_{that.deferMessages_},
         anyDeferredMessages_{that.anyDeferredMessages_},
         anyTokenMatched_{that.anyTokenMatched_} {}
   ParseState(ParseState &&that)
       : p_{that.p_}, limit_{that.limit_}, messages_{std::move(that.messages_)},
         context_{std::move(that.context_)}, userState_{that.userState_},
         inFixedForm_{that.inFixedForm_},
         anyErrorRecovery_{that.anyErrorRecovery_},
         anyConformanceViolation_{that.anyConformanceViolation_},
         deferMessages_{that.deferMessages_},
         anyDeferredMessages_{that.anyDeferredMessages_},
         anyTokenMatched_{that.anyTokenMatched_} {}
   ParseState &operator=(const ParseState &that) {
     p_ = that.p_, limit_ = that.limit_, context_ = that.context_;
     userState_ = that.userState_, inFixedForm_ = that.inFixedForm_;
     anyErrorRecovery_ = that.anyErrorRecovery_;
     anyConformanceViolation_ = that.anyConformanceViolation_;
     deferMessages_ = that.deferMessages_;
     anyDeferredMessages_ = that.anyDeferredMessages_;
     anyTokenMatched_ = that.anyTokenMatched_;
     return *this;
   }
   ParseState &operator=(ParseState &&that) {
     p_ = that.p_, limit_ = that.limit_, messages_ = std::move(that.messages_);
     context_ = std::move(that.context_);
     userState_ = that.userState_, inFixedForm_ = that.inFixedForm_;
     anyErrorRecovery_ = that.anyErrorRecovery_;
     anyConformanceViolation_ = that.anyConformanceViolation_;
     deferMessages_ = that.deferMessages_;
     anyDeferredMessages_ = that.anyDeferredMessages_;
     anyTokenMatched_ = that.anyTokenMatched_;
     return *this;
   }
 
   const Messages &messages() const { return messages_; }
   Messages &messages() { return messages_; }
 
   const Message::Reference &context() const { return context_; }
   Message::Reference &context() { return context_; }
 
   bool anyErrorRecovery() const { return anyErrorRecovery_; }
   void set_anyErrorRecovery() { anyErrorRecovery_ = true; }
 
   bool anyConformanceViolation() const { return anyConformanceViolation_; }
   void set_anyConformanceViolation() { anyConformanceViolation_ = true; }
 
   UserState *userState() const { return userState_; }
   ParseState &set_userState(UserState *u) {
     userState_ = u;
     return *this;
   }
 
   bool inFixedForm() const { return inFixedForm_; }
   ParseState &set_inFixedForm(bool yes = true) {
     inFixedForm_ = yes;
     return *this;
   }
 
   bool deferMessages() const { return deferMessages_; }
   ParseState &set_deferMessages(bool yes = true) {
     deferMessages_ = yes;
     return *this;
   }
 
   bool anyDeferredMessages() const { return anyDeferredMessages_; }
   ParseState &set_anyDeferredMessages(bool yes = true) {
     anyDeferredMessages_ = yes;
     return *this;
   }
 
   bool anyTokenMatched() const { return anyTokenMatched_; }
   ParseState &set_anyTokenMatched(bool yes = true) {
     anyTokenMatched_ = yes;
     return *this;
   }
 
   const char *GetLocation() const { return p_; }
 
   void PushContext(MessageFixedText text) {
     auto m{new Message{p_, text}}; // reference-counted
     m->SetContext(context_.get());
     context_ = Message::Reference{m};
   }
 
   void PopContext() {
     CHECK(context_);
     context_ = context_->attachment();
   }
 
-  template <typename... A> void Say(CharBlock range, A &&... args) {
+  template <typename... A> void Say(CharBlock range, A &&...args) {
     if (deferMessages_) {
       anyDeferredMessages_ = true;
     } else {
       messages_.Say(range, std::forward<A>(args)...).SetContext(context_.get());
     }
   }
-  template <typename... A>
-  void Say(const MessageFixedText &text, A &&... args) {
+  template <typename... A> void Say(const MessageFixedText &text, A &&...args) {
     Say(p_, text, std::forward<A>(args)...);
   }
   template <typename... A>
-  void Say(const MessageExpectedText &text, A &&... args) {
+  void Say(const MessageExpectedText &text, A &&...args) {
     Say(p_, text, std::forward<A>(args)...);
   }
 
   void Nonstandard(LanguageFeature lf, const MessageFixedText &msg) {
     Nonstandard(p_, lf, msg);
   }
   void Nonstandard(
       CharBlock range, LanguageFeature lf, const MessageFixedText &msg) {
     anyConformanceViolation_ = true;
     if (userState_ && userState_->features().ShouldWarn(lf)) {
       Say(range, msg);
     }
   }
   bool IsNonstandardOk(LanguageFeature lf, const MessageFixedText &msg) {
     if (userState_ && !userState_->features().IsEnabled(lf)) {
       return false;
     }
     Nonstandard(lf, msg);
     return true;
   }
 
   bool IsAtEnd() const { return p_ >= limit_; }
 
   const char *UncheckedAdvance(std::size_t n = 1) {
     const char *result{p_};
     p_ += n;
     return result;
   }
 
   std::optional<const char *> GetNextChar() {
     if (p_ < limit_) {
       return UncheckedAdvance();
     } else {
       return std::nullopt;
     }
   }
 
   std::optional<const char *> PeekAtNextChar() const {
     if (p_ < limit_) {
       return p_;
     } else {
       return std::nullopt;
     }
   }
 
   std::size_t BytesRemaining() const {
     std::size_t remain = limit_ - p_;
     return remain;
   }
 
   void CombineFailedParses(ParseState &&prev) {
     if (prev.anyTokenMatched_) {
       if (!anyTokenMatched_ || prev.p_ > p_) {
         anyTokenMatched_ = true;
         p_ = prev.p_;
         messages_ = std::move(prev.messages_);
       } else if (prev.p_ == p_) {
         messages_.Merge(std::move(prev.messages_));
       }
     }
     anyDeferredMessages_ |= prev.anyDeferredMessages_;
     anyConformanceViolation_ |= prev.anyConformanceViolation_;
     anyErrorRecovery_ |= prev.anyErrorRecovery_;
   }
 
 private:
   // Text remaining to be parsed
   const char *p_{nullptr}, *limit_{nullptr};
 
   // Accumulated messages and current nested context.
   Messages messages_;
   Message::Reference context_;
 
   UserState *userState_{nullptr};
 
   bool inFixedForm_{false};
   bool anyErrorRecovery_{false};
   bool anyConformanceViolation_{false};
   bool deferMessages_{false};
   bool anyDeferredMessages_{false};
   bool anyTokenMatched_{false};
   // NOTE: Any additions or modifications to these data members must also be
   // reflected in the copy and move constructors defined at the top of this
   // class definition!
 };
 } // namespace Fortran::parser
 #endif // FORTRAN_PARSER_PARSE_STATE_H_
diff --git a/flang/include/flang/Parser/parse-tree.h b/flang/include/flang/Parser/parse-tree.h
index c0a1a385801b..ebea3331ae5a 100644
--- a/flang/include/flang/Parser/parse-tree.h
+++ b/flang/include/flang/Parser/parse-tree.h
@@ -1,4092 +1,4092 @@
 //===-- include/flang/Parser/parse-tree.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_H_
 #define FORTRAN_PARSER_PARSE_TREE_H_
 
 // Defines the classes used to represent successful reductions of productions
 // in the Fortran grammar.  The names and content of these definitions
 // adhere closely to the syntax specifications in the language standard (q.v.)
 // that are transcribed here and referenced via their requirement numbers.
 // The representations of some productions that may also be of use in the
 // run-time I/O support library have been isolated into a distinct header file
 // (viz., format-specification.h).
 
 #include "char-block.h"
 #include "characters.h"
 #include "format-specification.h"
 #include "message.h"
 #include "provenance.h"
 #include "flang/Common/Fortran.h"
 #include "flang/Common/idioms.h"
 #include "flang/Common/indirection.h"
 #include "llvm/Frontend/OpenACC/ACC.h.inc"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 #include <cinttypes>
 #include <list>
 #include <memory>
 #include <optional>
 #include <string>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 #include <variant>
 
 // Parse tree node class types do not have default constructors.  They
 // explicitly declare "T() {} = delete;" to make this clear.  This restriction
 // prevents the introduction of what would be a viral requirement to include
 // std::monostate among most std::variant<> discriminated union members.
 
 // Parse tree node class types do not have copy constructors or copy assignment
 // operators.  They are explicitly declared "= delete;" to make this clear,
 // although a C++ compiler wouldn't default them anyway due to the presence
 // of explicitly defaulted move constructors and move assignments.
 
 CLASS_TRAIT(EmptyTrait)
 CLASS_TRAIT(WrapperTrait)
 CLASS_TRAIT(UnionTrait)
 CLASS_TRAIT(TupleTrait)
 CLASS_TRAIT(ConstraintTrait)
 
 // Some parse tree nodes have fields in them to cache the results of a
 // successful semantic analysis later.  Their types are forward declared
 // here.
 namespace Fortran::semantics {
 class Symbol;
 class DeclTypeSpec;
 class DerivedTypeSpec;
 } // namespace Fortran::semantics
 
 // Expressions in the parse tree have owning pointers that can be set to
 // type-checked generic expression representations by semantic analysis.
 namespace Fortran::evaluate {
 struct GenericExprWrapper; // forward definition, wraps Expr<SomeType>
 struct GenericAssignmentWrapper; // forward definition, represent assignment
 class ProcedureRef; // forward definition, represents a CALL statement
 } // namespace Fortran::evaluate
 
 // Most non-template classes in this file use these default definitions
 // for their move constructor and move assignment operator=, and disable
 // their copy constructor and copy assignment operator=.
 #define COPY_AND_ASSIGN_BOILERPLATE(classname) \
   classname(classname &&) = default; \
   classname &operator=(classname &&) = default; \
   classname(const classname &) = delete; \
   classname &operator=(const classname &) = delete
 
 // Almost all classes in this file have no default constructor.
 #define BOILERPLATE(classname) \
   COPY_AND_ASSIGN_BOILERPLATE(classname); \
   classname() = delete
 
 // Empty classes are often used below as alternatives in std::variant<>
 // discriminated unions.
 #define EMPTY_CLASS(classname) \
   struct classname { \
     classname() {} \
     classname(const classname &) {} \
     classname(classname &&) {} \
     classname &operator=(const classname &) { return *this; }; \
     classname &operator=(classname &&) { return *this; }; \
     using EmptyTrait = std::true_type; \
   }
 
 // Many classes below simply wrap a std::variant<> discriminated union,
 // which is conventionally named "u".
 #define UNION_CLASS_BOILERPLATE(classname) \
   template <typename A, typename = common::NoLvalue<A>> \
   classname(A &&x) : u(std::move(x)) {} \
   using UnionTrait = std::true_type; \
   BOILERPLATE(classname)
 
 // Many other classes below simply wrap a std::tuple<> structure, which
 // is conventionally named "t".
 #define TUPLE_CLASS_BOILERPLATE(classname) \
   template <typename... Ts, typename = common::NoLvalue<Ts...>> \
-  classname(Ts &&... args) : t(std::move(args)...) {} \
+  classname(Ts &&...args) : t(std::move(args)...) {} \
   using TupleTrait = std::true_type; \
   BOILERPLATE(classname)
 
 // Many other classes below simply wrap a single data member, which is
 // conventionally named "v".
 #define WRAPPER_CLASS_BOILERPLATE(classname, type) \
   BOILERPLATE(classname); \
   classname(type &&x) : v(std::move(x)) {} \
   using WrapperTrait = std::true_type; \
   type v
 
 #define WRAPPER_CLASS(classname, type) \
   struct classname { \
     WRAPPER_CLASS_BOILERPLATE(classname, type); \
   }
 
 namespace Fortran::parser {
 
 // These are the unavoidable recursively-defined productions of Fortran.
 // Some references to the representations of their parses require
 // indirection.  The Indirect<> pointer wrapper class is used to
 // enforce ownership semantics and non-nullability.
 struct SpecificationPart; // R504
 struct ExecutableConstruct; // R514
 struct ActionStmt; // R515
 struct AcImpliedDo; // R774
 struct DataImpliedDo; // R840
 struct Designator; // R901
 struct Variable; // R902
 struct Expr; // R1001
 struct WhereConstruct; // R1042
 struct ForallConstruct; // R1050
 struct InputImpliedDo; // R1218
 struct OutputImpliedDo; // R1218
 struct FunctionReference; // R1520
 struct FunctionSubprogram; // R1529
 struct SubroutineSubprogram; // R1534
 
 // These additional forward references are declared so that the order of
 // class definitions in this header file can remain reasonably consistent
 // with order of the the requirement productions in the grammar.
 struct DerivedTypeDef; // R726
 struct EnumDef; // R759
 struct TypeDeclarationStmt; // R801
 struct AccessStmt; // R827
 struct AllocatableStmt; // R829
 struct AsynchronousStmt; // R831
 struct BindStmt; // R832
 struct CodimensionStmt; // R834
 struct ContiguousStmt; // R836
 struct DataStmt; // R837
 struct DataStmtValue; // R843
 struct DimensionStmt; // R848
 struct IntentStmt; // R849
 struct OptionalStmt; // R850
 struct ParameterStmt; // R851
 struct OldParameterStmt;
 struct PointerStmt; // R853
 struct ProtectedStmt; // R855
 struct SaveStmt; // R856
 struct TargetStmt; // R859
 struct ValueStmt; // R861
 struct VolatileStmt; // R862
 struct ImplicitStmt; // R863
 struct ImportStmt; // R867
 struct NamelistStmt; // R868
 struct EquivalenceStmt; // R870
 struct CommonStmt; // R873
 struct Substring; // R908
 struct CharLiteralConstantSubstring;
 struct DataRef; // R911
 struct StructureComponent; // R913
 struct CoindexedNamedObject; // R914
 struct ArrayElement; // R917
 struct AllocateStmt; // R927
 struct NullifyStmt; // R939
 struct DeallocateStmt; // R941
 struct AssignmentStmt; // R1032
 struct PointerAssignmentStmt; // R1033
 struct WhereStmt; // R1041, R1045, R1046
 struct ForallStmt; // R1055
 struct AssociateConstruct; // R1102
 struct BlockConstruct; // R1107
 struct ChangeTeamConstruct; // R1111
 struct CriticalConstruct; // R1116
 struct DoConstruct; // R1119
 struct LabelDoStmt; // R1121
 struct ConcurrentHeader; // R1125
 struct EndDoStmt; // R1132
 struct CycleStmt; // R1133
 struct IfConstruct; // R1134
 struct IfStmt; // R1139
 struct CaseConstruct; // R1140
 struct SelectRankConstruct; // R1148
 struct SelectTypeConstruct; // R1152
 struct ExitStmt; // R1156
 struct GotoStmt; // R1157
 struct ComputedGotoStmt; // R1158
 struct StopStmt; // R1160, R1161
 struct SyncAllStmt; // R1164
 struct SyncImagesStmt; // R1166
 struct SyncMemoryStmt; // R1168
 struct SyncTeamStmt; // R1169
 struct EventPostStmt; // R1170, R1171
 struct EventWaitStmt; // R1172, R1173, R1174
 struct FormTeamStmt; // R1175, R1176, R1177
 struct LockStmt; // R1178
 struct UnlockStmt; // R1180
 struct OpenStmt; // R1204
 struct CloseStmt; // R1208
 struct ReadStmt; // R1210
 struct WriteStmt; // R1211
 struct PrintStmt; // R1212
 struct WaitStmt; // R1222
 struct BackspaceStmt; // R1224
 struct EndfileStmt; // R1225
 struct RewindStmt; // R1226
 struct FlushStmt; // R1228
 struct InquireStmt; // R1230
 struct FormatStmt; // R1301
 struct MainProgram; // R1401
 struct Module; // R1404
 struct UseStmt; // R1409
 struct Submodule; // R1416
 struct BlockData; // R1420
 struct InterfaceBlock; // R1501
 struct GenericSpec; // R1508
 struct GenericStmt; // R1510
 struct ExternalStmt; // R1511
 struct ProcedureDeclarationStmt; // R1512
 struct IntrinsicStmt; // R1519
 struct Call; // R1520 & R1521
 struct CallStmt; // R1521
 struct ProcedureDesignator; // R1522
 struct ActualArg; // R1524
 struct SeparateModuleSubprogram; // R1538
 struct EntryStmt; // R1541
 struct ReturnStmt; // R1542
 struct StmtFunctionStmt; // R1544
 
 // Directives, extensions, and deprecated statements
 struct CompilerDirective;
 struct BasedPointerStmt;
 struct StructureDef;
 struct ArithmeticIfStmt;
 struct AssignStmt;
 struct AssignedGotoStmt;
 struct PauseStmt;
 struct OpenACCConstruct;
 struct OpenACCDeclarativeConstruct;
 struct OpenMPConstruct;
 struct OpenMPDeclarativeConstruct;
 struct OmpEndLoopDirective;
 
 // Cooked character stream locations
 using Location = const char *;
 
 // A parse tree node with provenance only
 struct Verbatim {
   BOILERPLATE(Verbatim);
   using EmptyTrait = std::true_type;
   CharBlock source;
 };
 
 // Implicit definitions of the Standard
 
 // R403 scalar-xyz -> xyz
 // These template class wrappers correspond to the Standard's modifiers
 // scalar-xyz, constant-xzy, int-xzy, default-char-xyz, & logical-xyz.
 template <typename A> struct Scalar {
   using ConstraintTrait = std::true_type;
   Scalar(Scalar &&that) = default;
   Scalar(A &&that) : thing(std::move(that)) {}
   Scalar &operator=(Scalar &&) = default;
   A thing;
 };
 
 template <typename A> struct Constant {
   using ConstraintTrait = std::true_type;
   Constant(Constant &&that) = default;
   Constant(A &&that) : thing(std::move(that)) {}
   Constant &operator=(Constant &&) = default;
   A thing;
 };
 
 template <typename A> struct Integer {
   using ConstraintTrait = std::true_type;
   Integer(Integer &&that) = default;
   Integer(A &&that) : thing(std::move(that)) {}
   Integer &operator=(Integer &&) = default;
   A thing;
 };
 
 template <typename A> struct Logical {
   using ConstraintTrait = std::true_type;
   Logical(Logical &&that) = default;
   Logical(A &&that) : thing(std::move(that)) {}
   Logical &operator=(Logical &&) = default;
   A thing;
 };
 
 template <typename A> struct DefaultChar {
   using ConstraintTrait = std::true_type;
   DefaultChar(DefaultChar &&that) = default;
   DefaultChar(A &&that) : thing(std::move(that)) {}
   DefaultChar &operator=(DefaultChar &&) = default;
   A thing;
 };
 
 using LogicalExpr = Logical<common::Indirection<Expr>>; // R1024
 using DefaultCharExpr = DefaultChar<common::Indirection<Expr>>; // R1025
 using IntExpr = Integer<common::Indirection<Expr>>; // R1026
 using ConstantExpr = Constant<common::Indirection<Expr>>; // R1029
 using IntConstantExpr = Integer<ConstantExpr>; // R1031
 using ScalarLogicalExpr = Scalar<LogicalExpr>;
 using ScalarIntExpr = Scalar<IntExpr>;
 using ScalarIntConstantExpr = Scalar<IntConstantExpr>;
 using ScalarDefaultCharExpr = Scalar<DefaultCharExpr>;
 // R1030 default-char-constant-expr is used in the Standard only as part of
 // scalar-default-char-constant-expr.
 using ScalarDefaultCharConstantExpr = Scalar<DefaultChar<ConstantExpr>>;
 
 // R611 label -> digit [digit]...
 using Label = std::uint64_t; // validated later, must be in [1..99999]
 
 // A wrapper for xzy-stmt productions that are statements, so that
 // source provenances and labels have a uniform representation.
 template <typename A> struct UnlabeledStatement {
   explicit UnlabeledStatement(A &&s) : statement(std::move(s)) {}
   CharBlock source;
   A statement;
 };
 template <typename A> struct Statement : public UnlabeledStatement<A> {
   Statement(std::optional<long> &&lab, A &&s)
       : UnlabeledStatement<A>{std::move(s)}, label(std::move(lab)) {}
   std::optional<Label> label;
 };
 
 // Error recovery marker
 EMPTY_CLASS(ErrorRecovery);
 
 // R513 other-specification-stmt ->
 //        access-stmt | allocatable-stmt | asynchronous-stmt | bind-stmt |
 //        codimension-stmt | contiguous-stmt | dimension-stmt | external-stmt |
 //        intent-stmt | intrinsic-stmt | namelist-stmt | optional-stmt |
 //        pointer-stmt | protected-stmt | save-stmt | target-stmt |
 //        volatile-stmt | value-stmt | common-stmt | equivalence-stmt
 // Extension: (Cray) based POINTER statement
 struct OtherSpecificationStmt {
   UNION_CLASS_BOILERPLATE(OtherSpecificationStmt);
   std::variant<common::Indirection<AccessStmt>,
       common::Indirection<AllocatableStmt>,
       common::Indirection<AsynchronousStmt>, common::Indirection<BindStmt>,
       common::Indirection<CodimensionStmt>, common::Indirection<ContiguousStmt>,
       common::Indirection<DimensionStmt>, common::Indirection<ExternalStmt>,
       common::Indirection<IntentStmt>, common::Indirection<IntrinsicStmt>,
       common::Indirection<NamelistStmt>, common::Indirection<OptionalStmt>,
       common::Indirection<PointerStmt>, common::Indirection<ProtectedStmt>,
       common::Indirection<SaveStmt>, common::Indirection<TargetStmt>,
       common::Indirection<ValueStmt>, common::Indirection<VolatileStmt>,
       common::Indirection<CommonStmt>, common::Indirection<EquivalenceStmt>,
       common::Indirection<BasedPointerStmt>>
       u;
 };
 
 // R508 specification-construct ->
 //        derived-type-def | enum-def | generic-stmt | interface-block |
 //        parameter-stmt | procedure-declaration-stmt |
 //        other-specification-stmt | type-declaration-stmt
 struct SpecificationConstruct {
   UNION_CLASS_BOILERPLATE(SpecificationConstruct);
   std::variant<common::Indirection<DerivedTypeDef>,
       common::Indirection<EnumDef>, Statement<common::Indirection<GenericStmt>>,
       common::Indirection<InterfaceBlock>,
       Statement<common::Indirection<ParameterStmt>>,
       Statement<common::Indirection<OldParameterStmt>>,
       Statement<common::Indirection<ProcedureDeclarationStmt>>,
       Statement<OtherSpecificationStmt>,
       Statement<common::Indirection<TypeDeclarationStmt>>,
       common::Indirection<StructureDef>,
       common::Indirection<OpenACCDeclarativeConstruct>,
       common::Indirection<OpenMPDeclarativeConstruct>,
       common::Indirection<CompilerDirective>>
       u;
 };
 
 // R506 implicit-part-stmt ->
 //         implicit-stmt | parameter-stmt | format-stmt | entry-stmt
 struct ImplicitPartStmt {
   UNION_CLASS_BOILERPLATE(ImplicitPartStmt);
   std::variant<Statement<common::Indirection<ImplicitStmt>>,
       Statement<common::Indirection<ParameterStmt>>,
       Statement<common::Indirection<OldParameterStmt>>,
       Statement<common::Indirection<FormatStmt>>,
       Statement<common::Indirection<EntryStmt>>>
       u;
 };
 
 // R505 implicit-part -> [implicit-part-stmt]... implicit-stmt
 WRAPPER_CLASS(ImplicitPart, std::list<ImplicitPartStmt>);
 
 // R507 declaration-construct ->
 //        specification-construct | data-stmt | format-stmt |
 //        entry-stmt | stmt-function-stmt
 struct DeclarationConstruct {
   UNION_CLASS_BOILERPLATE(DeclarationConstruct);
   std::variant<SpecificationConstruct, Statement<common::Indirection<DataStmt>>,
       Statement<common::Indirection<FormatStmt>>,
       Statement<common::Indirection<EntryStmt>>,
       Statement<common::Indirection<StmtFunctionStmt>>, ErrorRecovery>
       u;
 };
 
 // R504 specification-part -> [use-stmt]... [import-stmt]... [implicit-part]
 //                            [declaration-construct]...
 // TODO: transfer any statements after the last IMPLICIT (if any)
 // from the implicit part to the declaration constructs
 struct SpecificationPart {
   TUPLE_CLASS_BOILERPLATE(SpecificationPart);
   std::tuple<std::list<OpenACCDeclarativeConstruct>,
       std::list<OpenMPDeclarativeConstruct>,
       std::list<Statement<common::Indirection<UseStmt>>>,
       std::list<Statement<common::Indirection<ImportStmt>>>, ImplicitPart,
       std::list<DeclarationConstruct>>
       t;
 };
 
 // R512 internal-subprogram -> function-subprogram | subroutine-subprogram
 struct InternalSubprogram {
   UNION_CLASS_BOILERPLATE(InternalSubprogram);
   std::variant<common::Indirection<FunctionSubprogram>,
       common::Indirection<SubroutineSubprogram>>
       u;
 };
 
 // R1543 contains-stmt -> CONTAINS
 EMPTY_CLASS(ContainsStmt);
 
 // R511 internal-subprogram-part -> contains-stmt [internal-subprogram]...
 struct InternalSubprogramPart {
   TUPLE_CLASS_BOILERPLATE(InternalSubprogramPart);
   std::tuple<Statement<ContainsStmt>, std::list<InternalSubprogram>> t;
 };
 
 // R1159 continue-stmt -> CONTINUE
 EMPTY_CLASS(ContinueStmt);
 
 // R1163 fail-image-stmt -> FAIL IMAGE
 EMPTY_CLASS(FailImageStmt);
 
 // R515 action-stmt ->
 //        allocate-stmt | assignment-stmt | backspace-stmt | call-stmt |
 //        close-stmt | continue-stmt | cycle-stmt | deallocate-stmt |
 //        endfile-stmt | error-stop-stmt | event-post-stmt | event-wait-stmt |
 //        exit-stmt | fail-image-stmt | flush-stmt | form-team-stmt |
 //        goto-stmt | if-stmt | inquire-stmt | lock-stmt | nullify-stmt |
 //        open-stmt | pointer-assignment-stmt | print-stmt | read-stmt |
 //        return-stmt | rewind-stmt | stop-stmt | sync-all-stmt |
 //        sync-images-stmt | sync-memory-stmt | sync-team-stmt | unlock-stmt |
 //        wait-stmt | where-stmt | write-stmt | computed-goto-stmt | forall-stmt
 struct ActionStmt {
   UNION_CLASS_BOILERPLATE(ActionStmt);
   std::variant<common::Indirection<AllocateStmt>,
       common::Indirection<AssignmentStmt>, common::Indirection<BackspaceStmt>,
       common::Indirection<CallStmt>, common::Indirection<CloseStmt>,
       ContinueStmt, common::Indirection<CycleStmt>,
       common::Indirection<DeallocateStmt>, common::Indirection<EndfileStmt>,
       common::Indirection<EventPostStmt>, common::Indirection<EventWaitStmt>,
       common::Indirection<ExitStmt>, FailImageStmt,
       common::Indirection<FlushStmt>, common::Indirection<FormTeamStmt>,
       common::Indirection<GotoStmt>, common::Indirection<IfStmt>,
       common::Indirection<InquireStmt>, common::Indirection<LockStmt>,
       common::Indirection<NullifyStmt>, common::Indirection<OpenStmt>,
       common::Indirection<PointerAssignmentStmt>,
       common::Indirection<PrintStmt>, common::Indirection<ReadStmt>,
       common::Indirection<ReturnStmt>, common::Indirection<RewindStmt>,
       common::Indirection<StopStmt>, common::Indirection<SyncAllStmt>,
       common::Indirection<SyncImagesStmt>, common::Indirection<SyncMemoryStmt>,
       common::Indirection<SyncTeamStmt>, common::Indirection<UnlockStmt>,
       common::Indirection<WaitStmt>, common::Indirection<WhereStmt>,
       common::Indirection<WriteStmt>, common::Indirection<ComputedGotoStmt>,
       common::Indirection<ForallStmt>, common::Indirection<ArithmeticIfStmt>,
       common::Indirection<AssignStmt>, common::Indirection<AssignedGotoStmt>,
       common::Indirection<PauseStmt>>
       u;
 };
 
 // R514 executable-construct ->
 //        action-stmt | associate-construct | block-construct |
 //        case-construct | change-team-construct | critical-construct |
 //        do-construct | if-construct | select-rank-construct |
 //        select-type-construct | where-construct | forall-construct
 struct ExecutableConstruct {
   UNION_CLASS_BOILERPLATE(ExecutableConstruct);
   std::variant<Statement<ActionStmt>, common::Indirection<AssociateConstruct>,
       common::Indirection<BlockConstruct>, common::Indirection<CaseConstruct>,
       common::Indirection<ChangeTeamConstruct>,
       common::Indirection<CriticalConstruct>,
       Statement<common::Indirection<LabelDoStmt>>,
       Statement<common::Indirection<EndDoStmt>>,
       common::Indirection<DoConstruct>, common::Indirection<IfConstruct>,
       common::Indirection<SelectRankConstruct>,
       common::Indirection<SelectTypeConstruct>,
       common::Indirection<WhereConstruct>, common::Indirection<ForallConstruct>,
       common::Indirection<CompilerDirective>,
       common::Indirection<OpenACCConstruct>,
       common::Indirection<OpenMPConstruct>,
       common::Indirection<OmpEndLoopDirective>>
       u;
 };
 
 // R510 execution-part-construct ->
 //        executable-construct | format-stmt | entry-stmt | data-stmt
 // Extension (PGI/Intel): also accept NAMELIST in execution part
 struct ExecutionPartConstruct {
   UNION_CLASS_BOILERPLATE(ExecutionPartConstruct);
   std::variant<ExecutableConstruct, Statement<common::Indirection<FormatStmt>>,
       Statement<common::Indirection<EntryStmt>>,
       Statement<common::Indirection<DataStmt>>,
       Statement<common::Indirection<NamelistStmt>>, ErrorRecovery>
       u;
 };
 
 // R509 execution-part -> executable-construct [execution-part-construct]...
 WRAPPER_CLASS(ExecutionPart, std::list<ExecutionPartConstruct>);
 
 // R502 program-unit ->
 //        main-program | external-subprogram | module | submodule | block-data
 // R503 external-subprogram -> function-subprogram | subroutine-subprogram
 struct ProgramUnit {
   UNION_CLASS_BOILERPLATE(ProgramUnit);
   std::variant<common::Indirection<MainProgram>,
       common::Indirection<FunctionSubprogram>,
       common::Indirection<SubroutineSubprogram>, common::Indirection<Module>,
       common::Indirection<Submodule>, common::Indirection<BlockData>>
       u;
 };
 
 // R501 program -> program-unit [program-unit]...
 // This is the top-level production.
 WRAPPER_CLASS(Program, std::list<ProgramUnit>);
 
 // R603 name -> letter [alphanumeric-character]...
 struct Name {
   std::string ToString() const { return source.ToString(); }
   CharBlock source;
   mutable semantics::Symbol *symbol{nullptr}; // filled in during semantics
 };
 
 // R516 keyword -> name
 WRAPPER_CLASS(Keyword, Name);
 
 // R606 named-constant -> name
 WRAPPER_CLASS(NamedConstant, Name);
 
 // R1003 defined-unary-op -> . letter [letter]... .
 // R1023 defined-binary-op -> . letter [letter]... .
 // R1414 local-defined-operator -> defined-unary-op | defined-binary-op
 // R1415 use-defined-operator -> defined-unary-op | defined-binary-op
 // The Name here is stored with the dots; e.g., .FOO.
 WRAPPER_CLASS(DefinedOpName, Name);
 
 // R608 intrinsic-operator ->
 //        ** | * | / | + | - | // | .LT. | .LE. | .EQ. | .NE. | .GE. | .GT. |
 //        .NOT. | .AND. | .OR. | .EQV. | .NEQV.
 // R609 defined-operator ->
 //        defined-unary-op | defined-binary-op | extended-intrinsic-op
 // R610 extended-intrinsic-op -> intrinsic-operator
 struct DefinedOperator {
   UNION_CLASS_BOILERPLATE(DefinedOperator);
   ENUM_CLASS(IntrinsicOperator, Power, Multiply, Divide, Add, Subtract, Concat,
       LT, LE, EQ, NE, GE, GT, NOT, AND, OR, EQV, NEQV)
   std::variant<DefinedOpName, IntrinsicOperator> u;
 };
 
 // R804 object-name -> name
 using ObjectName = Name;
 
 // R867 import-stmt ->
 //        IMPORT [[::] import-name-list] |
 //        IMPORT , ONLY : import-name-list | IMPORT , NONE | IMPORT , ALL
 struct ImportStmt {
   BOILERPLATE(ImportStmt);
   ImportStmt(common::ImportKind &&k) : kind{k} {}
   ImportStmt(std::list<Name> &&n) : names(std::move(n)) {}
   ImportStmt(common::ImportKind &&, std::list<Name> &&);
   common::ImportKind kind{common::ImportKind::Default};
   std::list<Name> names;
 };
 
 // R868 namelist-stmt ->
 //        NAMELIST / namelist-group-name / namelist-group-object-list
 //        [[,] / namelist-group-name / namelist-group-object-list]...
 // R869 namelist-group-object -> variable-name
 struct NamelistStmt {
   struct Group {
     TUPLE_CLASS_BOILERPLATE(Group);
     std::tuple<Name, std::list<Name>> t;
   };
   WRAPPER_CLASS_BOILERPLATE(NamelistStmt, std::list<Group>);
 };
 
 // R701 type-param-value -> scalar-int-expr | * | :
 EMPTY_CLASS(Star);
 
 struct TypeParamValue {
   UNION_CLASS_BOILERPLATE(TypeParamValue);
   EMPTY_CLASS(Deferred); // :
   std::variant<ScalarIntExpr, Star, Deferred> u;
 };
 
 // R706 kind-selector -> ( [KIND =] scalar-int-constant-expr )
 // Legacy extension: kind-selector -> * digit-string
 // N.B. These are not semantically identical in the case of COMPLEX.
 struct KindSelector {
   UNION_CLASS_BOILERPLATE(KindSelector);
   WRAPPER_CLASS(StarSize, std::uint64_t);
   std::variant<ScalarIntConstantExpr, StarSize> u;
 };
 
 // R705 integer-type-spec -> INTEGER [kind-selector]
 WRAPPER_CLASS(IntegerTypeSpec, std::optional<KindSelector>);
 
 // R723 char-length -> ( type-param-value ) | digit-string
 struct CharLength {
   UNION_CLASS_BOILERPLATE(CharLength);
   std::variant<TypeParamValue, std::uint64_t> u;
 };
 
 // R722 length-selector -> ( [LEN =] type-param-value ) | * char-length [,]
 struct LengthSelector {
   UNION_CLASS_BOILERPLATE(LengthSelector);
   std::variant<TypeParamValue, CharLength> u;
 };
 
 // R721 char-selector ->
 //        length-selector |
 //        ( LEN = type-param-value , KIND = scalar-int-constant-expr ) |
 //        ( type-param-value , [KIND =] scalar-int-constant-expr ) |
 //        ( KIND = scalar-int-constant-expr [, LEN = type-param-value] )
 struct CharSelector {
   UNION_CLASS_BOILERPLATE(CharSelector);
   struct LengthAndKind {
     BOILERPLATE(LengthAndKind);
     LengthAndKind(std::optional<TypeParamValue> &&l, ScalarIntConstantExpr &&k)
         : length(std::move(l)), kind(std::move(k)) {}
     std::optional<TypeParamValue> length;
     ScalarIntConstantExpr kind;
   };
   CharSelector(TypeParamValue &&l, ScalarIntConstantExpr &&k)
       : u{LengthAndKind{std::make_optional(std::move(l)), std::move(k)}} {}
   CharSelector(ScalarIntConstantExpr &&k, std::optional<TypeParamValue> &&l)
       : u{LengthAndKind{std::move(l), std::move(k)}} {}
   std::variant<LengthSelector, LengthAndKind> u;
 };
 
 // R704 intrinsic-type-spec ->
 //        integer-type-spec | REAL [kind-selector] | DOUBLE PRECISION |
 //        COMPLEX [kind-selector] | CHARACTER [char-selector] |
 //        LOGICAL [kind-selector]
 // Extensions: DOUBLE COMPLEX
 struct IntrinsicTypeSpec {
   UNION_CLASS_BOILERPLATE(IntrinsicTypeSpec);
   struct Real {
     BOILERPLATE(Real);
     Real(std::optional<KindSelector> &&k) : kind{std::move(k)} {}
     std::optional<KindSelector> kind;
   };
   EMPTY_CLASS(DoublePrecision);
   struct Complex {
     BOILERPLATE(Complex);
     Complex(std::optional<KindSelector> &&k) : kind{std::move(k)} {}
     std::optional<KindSelector> kind;
   };
   struct Character {
     BOILERPLATE(Character);
     Character(std::optional<CharSelector> &&s) : selector{std::move(s)} {}
     std::optional<CharSelector> selector;
   };
   struct Logical {
     BOILERPLATE(Logical);
     Logical(std::optional<KindSelector> &&k) : kind{std::move(k)} {}
     std::optional<KindSelector> kind;
   };
   EMPTY_CLASS(DoubleComplex);
   std::variant<IntegerTypeSpec, Real, DoublePrecision, Complex, Character,
       Logical, DoubleComplex>
       u;
 };
 
 // R755 type-param-spec -> [keyword =] type-param-value
 struct TypeParamSpec {
   TUPLE_CLASS_BOILERPLATE(TypeParamSpec);
   std::tuple<std::optional<Keyword>, TypeParamValue> t;
 };
 
 // R754 derived-type-spec -> type-name [(type-param-spec-list)]
 struct DerivedTypeSpec {
   TUPLE_CLASS_BOILERPLATE(DerivedTypeSpec);
   mutable const semantics::DerivedTypeSpec *derivedTypeSpec{nullptr};
   std::tuple<Name, std::list<TypeParamSpec>> t;
 };
 
 // R702 type-spec -> intrinsic-type-spec | derived-type-spec
 struct TypeSpec {
   UNION_CLASS_BOILERPLATE(TypeSpec);
   mutable const semantics::DeclTypeSpec *declTypeSpec{nullptr};
   std::variant<IntrinsicTypeSpec, DerivedTypeSpec> u;
 };
 
 // R703 declaration-type-spec ->
 //        intrinsic-type-spec | TYPE ( intrinsic-type-spec ) |
 //        TYPE ( derived-type-spec ) | CLASS ( derived-type-spec ) |
 //        CLASS ( * ) | TYPE ( * )
 // Legacy extension: RECORD /struct/
 struct DeclarationTypeSpec {
   UNION_CLASS_BOILERPLATE(DeclarationTypeSpec);
   struct Type {
     BOILERPLATE(Type);
     Type(DerivedTypeSpec &&dt) : derived(std::move(dt)) {}
     DerivedTypeSpec derived;
   };
   struct Class {
     BOILERPLATE(Class);
     Class(DerivedTypeSpec &&dt) : derived(std::move(dt)) {}
     DerivedTypeSpec derived;
   };
   EMPTY_CLASS(ClassStar);
   EMPTY_CLASS(TypeStar);
   WRAPPER_CLASS(Record, Name);
   std::variant<IntrinsicTypeSpec, Type, Class, ClassStar, TypeStar, Record> u;
 };
 
 // R709 kind-param -> digit-string | scalar-int-constant-name
 struct KindParam {
   UNION_CLASS_BOILERPLATE(KindParam);
   std::variant<std::uint64_t, Scalar<Integer<Constant<Name>>>> u;
 };
 
 // R707 signed-int-literal-constant -> [sign] int-literal-constant
 struct SignedIntLiteralConstant {
   TUPLE_CLASS_BOILERPLATE(SignedIntLiteralConstant);
   CharBlock source;
   std::tuple<CharBlock, std::optional<KindParam>> t;
 };
 
 // R708 int-literal-constant -> digit-string [_ kind-param]
 struct IntLiteralConstant {
   TUPLE_CLASS_BOILERPLATE(IntLiteralConstant);
   std::tuple<CharBlock, std::optional<KindParam>> t;
 };
 
 // R712 sign -> + | -
 enum class Sign { Positive, Negative };
 
 // R714 real-literal-constant ->
 //        significand [exponent-letter exponent] [_ kind-param] |
 //        digit-string exponent-letter exponent [_ kind-param]
 // R715 significand -> digit-string . [digit-string] | . digit-string
 // R717 exponent -> signed-digit-string
 struct RealLiteralConstant {
   BOILERPLATE(RealLiteralConstant);
   struct Real {
     COPY_AND_ASSIGN_BOILERPLATE(Real);
     Real() {}
     CharBlock source;
   };
   RealLiteralConstant(Real &&r, std::optional<KindParam> &&k)
       : real{std::move(r)}, kind{std::move(k)} {}
   Real real;
   std::optional<KindParam> kind;
 };
 
 // R713 signed-real-literal-constant -> [sign] real-literal-constant
 struct SignedRealLiteralConstant {
   TUPLE_CLASS_BOILERPLATE(SignedRealLiteralConstant);
   std::tuple<std::optional<Sign>, RealLiteralConstant> t;
 };
 
 // R719 real-part ->
 //        signed-int-literal-constant | signed-real-literal-constant |
 //        named-constant
 // R720 imag-part ->
 //        signed-int-literal-constant | signed-real-literal-constant |
 //        named-constant
 struct ComplexPart {
   UNION_CLASS_BOILERPLATE(ComplexPart);
   std::variant<SignedIntLiteralConstant, SignedRealLiteralConstant,
       NamedConstant>
       u;
 };
 
 // R718 complex-literal-constant -> ( real-part , imag-part )
 struct ComplexLiteralConstant {
   TUPLE_CLASS_BOILERPLATE(ComplexLiteralConstant);
   std::tuple<ComplexPart, ComplexPart> t; // real, imaginary
 };
 
 // Extension: signed COMPLEX constant
 struct SignedComplexLiteralConstant {
   TUPLE_CLASS_BOILERPLATE(SignedComplexLiteralConstant);
   std::tuple<Sign, ComplexLiteralConstant> t;
 };
 
 // R724 char-literal-constant ->
 //        [kind-param _] ' [rep-char]... ' |
 //        [kind-param _] " [rep-char]... "
 struct CharLiteralConstant {
   TUPLE_CLASS_BOILERPLATE(CharLiteralConstant);
   std::tuple<std::optional<KindParam>, std::string> t;
   std::string GetString() const { return std::get<std::string>(t); }
 };
 
 // legacy extension
 struct HollerithLiteralConstant {
   WRAPPER_CLASS_BOILERPLATE(HollerithLiteralConstant, std::string);
   std::string GetString() const { return v; }
 };
 
 // R725 logical-literal-constant ->
 //        .TRUE. [_ kind-param] | .FALSE. [_ kind-param]
 struct LogicalLiteralConstant {
   TUPLE_CLASS_BOILERPLATE(LogicalLiteralConstant);
   std::tuple<bool, std::optional<KindParam>> t;
 };
 
 // R764 boz-literal-constant -> binary-constant | octal-constant | hex-constant
 // R765 binary-constant -> B ' digit [digit]... ' | B " digit [digit]... "
 // R766 octal-constant -> O ' digit [digit]... ' | O " digit [digit]... "
 // R767 hex-constant ->
 //        Z ' hex-digit [hex-digit]... ' | Z " hex-digit [hex-digit]... "
 // The constant must be large enough to hold any real or integer scalar
 // of any supported kind (F'2018 7.7).
 WRAPPER_CLASS(BOZLiteralConstant, std::string);
 
 // R605 literal-constant ->
 //        int-literal-constant | real-literal-constant |
 //        complex-literal-constant | logical-literal-constant |
 //        char-literal-constant | boz-literal-constant
 struct LiteralConstant {
   UNION_CLASS_BOILERPLATE(LiteralConstant);
   std::variant<HollerithLiteralConstant, IntLiteralConstant,
       RealLiteralConstant, ComplexLiteralConstant, BOZLiteralConstant,
       CharLiteralConstant, LogicalLiteralConstant>
       u;
 };
 
 // R604 constant ->  literal-constant | named-constant
 // Renamed to dodge a clash with Constant<> template class.
 struct ConstantValue {
   UNION_CLASS_BOILERPLATE(ConstantValue);
   std::variant<LiteralConstant, NamedConstant> u;
 };
 
 // R807 access-spec -> PUBLIC | PRIVATE
 struct AccessSpec {
   ENUM_CLASS(Kind, Public, Private)
   WRAPPER_CLASS_BOILERPLATE(AccessSpec, Kind);
 };
 
 // R728 type-attr-spec ->
 //        ABSTRACT | access-spec | BIND(C) | EXTENDS ( parent-type-name )
 EMPTY_CLASS(Abstract);
 struct TypeAttrSpec {
   UNION_CLASS_BOILERPLATE(TypeAttrSpec);
   EMPTY_CLASS(BindC);
   WRAPPER_CLASS(Extends, Name);
   std::variant<Abstract, AccessSpec, BindC, Extends> u;
 };
 
 // R727 derived-type-stmt ->
 //        TYPE [[, type-attr-spec-list] ::] type-name [( type-param-name-list )]
 struct DerivedTypeStmt {
   TUPLE_CLASS_BOILERPLATE(DerivedTypeStmt);
   std::tuple<std::list<TypeAttrSpec>, Name, std::list<Name>> t;
 };
 
 // R731 sequence-stmt -> SEQUENCE
 EMPTY_CLASS(SequenceStmt);
 
 // R745 private-components-stmt -> PRIVATE
 // R747 binding-private-stmt -> PRIVATE
 EMPTY_CLASS(PrivateStmt);
 
 // R729 private-or-sequence -> private-components-stmt | sequence-stmt
 struct PrivateOrSequence {
   UNION_CLASS_BOILERPLATE(PrivateOrSequence);
   std::variant<PrivateStmt, SequenceStmt> u;
 };
 
 // R733 type-param-decl -> type-param-name [= scalar-int-constant-expr]
 struct TypeParamDecl {
   TUPLE_CLASS_BOILERPLATE(TypeParamDecl);
   std::tuple<Name, std::optional<ScalarIntConstantExpr>> t;
 };
 
 // R732 type-param-def-stmt ->
 //        integer-type-spec , type-param-attr-spec :: type-param-decl-list
 // R734 type-param-attr-spec -> KIND | LEN
 struct TypeParamDefStmt {
   TUPLE_CLASS_BOILERPLATE(TypeParamDefStmt);
   std::tuple<IntegerTypeSpec, common::TypeParamAttr, std::list<TypeParamDecl>>
       t;
 };
 
 // R1028 specification-expr -> scalar-int-expr
 WRAPPER_CLASS(SpecificationExpr, ScalarIntExpr);
 
 // R816 explicit-shape-spec -> [lower-bound :] upper-bound
 // R817 lower-bound -> specification-expr
 // R818 upper-bound -> specification-expr
 struct ExplicitShapeSpec {
   TUPLE_CLASS_BOILERPLATE(ExplicitShapeSpec);
   std::tuple<std::optional<SpecificationExpr>, SpecificationExpr> t;
 };
 
 // R810 deferred-coshape-spec -> :
 // deferred-coshape-spec-list is just a count of the colons (i.e., the rank).
 WRAPPER_CLASS(DeferredCoshapeSpecList, int);
 
 // R811 explicit-coshape-spec ->
 //        [[lower-cobound :] upper-cobound ,]... [lower-cobound :] *
 // R812 lower-cobound -> specification-expr
 // R813 upper-cobound -> specification-expr
 struct ExplicitCoshapeSpec {
   TUPLE_CLASS_BOILERPLATE(ExplicitCoshapeSpec);
   std::tuple<std::list<ExplicitShapeSpec>, std::optional<SpecificationExpr>> t;
 };
 
 // R809 coarray-spec -> deferred-coshape-spec-list | explicit-coshape-spec
 struct CoarraySpec {
   UNION_CLASS_BOILERPLATE(CoarraySpec);
   std::variant<DeferredCoshapeSpecList, ExplicitCoshapeSpec> u;
 };
 
 // R820 deferred-shape-spec -> :
 // deferred-shape-spec-list is just a count of the colons (i.e., the rank).
 WRAPPER_CLASS(DeferredShapeSpecList, int);
 
 // R740 component-array-spec ->
 //        explicit-shape-spec-list | deferred-shape-spec-list
 struct ComponentArraySpec {
   UNION_CLASS_BOILERPLATE(ComponentArraySpec);
   std::variant<std::list<ExplicitShapeSpec>, DeferredShapeSpecList> u;
 };
 
 // R738 component-attr-spec ->
 //        access-spec | ALLOCATABLE |
 //        CODIMENSION lbracket coarray-spec rbracket |
 //        CONTIGUOUS | DIMENSION ( component-array-spec ) | POINTER
 EMPTY_CLASS(Allocatable);
 EMPTY_CLASS(Pointer);
 EMPTY_CLASS(Contiguous);
 struct ComponentAttrSpec {
   UNION_CLASS_BOILERPLATE(ComponentAttrSpec);
   std::variant<AccessSpec, Allocatable, CoarraySpec, Contiguous,
       ComponentArraySpec, Pointer, ErrorRecovery>
       u;
 };
 
 // R806 null-init -> function-reference
 // TODO replace with semantic check on expression
 EMPTY_CLASS(NullInit);
 
 // R744 initial-data-target -> designator
 using InitialDataTarget = common::Indirection<Designator>;
 
 // R743 component-initialization ->
 //        = constant-expr | => null-init | => initial-data-target
 // R805 initialization ->
 //        = constant-expr | => null-init | => initial-data-target
 // Universal extension: initialization -> / data-stmt-value-list /
 struct Initialization {
   UNION_CLASS_BOILERPLATE(Initialization);
   std::variant<ConstantExpr, NullInit, InitialDataTarget,
       std::list<common::Indirection<DataStmtValue>>>
       u;
 };
 
 // R739 component-decl ->
 //        component-name [( component-array-spec )]
 //        [lbracket coarray-spec rbracket] [* char-length]
 //        [component-initialization]
 struct ComponentDecl {
   TUPLE_CLASS_BOILERPLATE(ComponentDecl);
   std::tuple<Name, std::optional<ComponentArraySpec>,
       std::optional<CoarraySpec>, std::optional<CharLength>,
       std::optional<Initialization>>
       t;
 };
 
 // R737 data-component-def-stmt ->
 //        declaration-type-spec [[, component-attr-spec-list] ::]
 //        component-decl-list
 struct DataComponentDefStmt {
   TUPLE_CLASS_BOILERPLATE(DataComponentDefStmt);
   std::tuple<DeclarationTypeSpec, std::list<ComponentAttrSpec>,
       std::list<ComponentDecl>>
       t;
 };
 
 // R742 proc-component-attr-spec ->
 //        access-spec | NOPASS | PASS [(arg-name)] | POINTER
 EMPTY_CLASS(NoPass);
 WRAPPER_CLASS(Pass, std::optional<Name>);
 struct ProcComponentAttrSpec {
   UNION_CLASS_BOILERPLATE(ProcComponentAttrSpec);
   std::variant<AccessSpec, NoPass, Pass, Pointer> u;
 };
 
 // R1517 proc-pointer-init -> null-init | initial-proc-target
 // R1518 initial-proc-target -> procedure-name
 struct ProcPointerInit {
   UNION_CLASS_BOILERPLATE(ProcPointerInit);
   std::variant<NullInit, Name> u;
 };
 
 // R1513 proc-interface -> interface-name | declaration-type-spec
 // R1516 interface-name -> name
 struct ProcInterface {
   UNION_CLASS_BOILERPLATE(ProcInterface);
   std::variant<Name, DeclarationTypeSpec> u;
 };
 
 // R1515 proc-decl -> procedure-entity-name [=> proc-pointer-init]
 struct ProcDecl {
   TUPLE_CLASS_BOILERPLATE(ProcDecl);
   std::tuple<Name, std::optional<ProcPointerInit>> t;
 };
 
 // R741 proc-component-def-stmt ->
 //        PROCEDURE ( [proc-interface] ) , proc-component-attr-spec-list
 //          :: proc-decl-list
 struct ProcComponentDefStmt {
   TUPLE_CLASS_BOILERPLATE(ProcComponentDefStmt);
   std::tuple<std::optional<ProcInterface>, std::list<ProcComponentAttrSpec>,
       std::list<ProcDecl>>
       t;
 };
 
 // R736 component-def-stmt -> data-component-def-stmt | proc-component-def-stmt
 struct ComponentDefStmt {
   UNION_CLASS_BOILERPLATE(ComponentDefStmt);
   std::variant<DataComponentDefStmt, ProcComponentDefStmt, ErrorRecovery
       // , TypeParamDefStmt -- PGI accidental extension, not enabled
       >
       u;
 };
 
 // R752 bind-attr ->
 //        access-spec | DEFERRED | NON_OVERRIDABLE | NOPASS | PASS [(arg-name)]
 struct BindAttr {
   UNION_CLASS_BOILERPLATE(BindAttr);
   EMPTY_CLASS(Deferred);
   EMPTY_CLASS(Non_Overridable);
   std::variant<AccessSpec, Deferred, Non_Overridable, NoPass, Pass> u;
 };
 
 // R750 type-bound-proc-decl -> binding-name [=> procedure-name]
 struct TypeBoundProcDecl {
   TUPLE_CLASS_BOILERPLATE(TypeBoundProcDecl);
   std::tuple<Name, std::optional<Name>> t;
 };
 
 // R749 type-bound-procedure-stmt ->
 //        PROCEDURE [[, bind-attr-list] ::] type-bound-proc-decl-list |
 //        PROCEDURE ( interface-name ) , bind-attr-list :: binding-name-list
 // The second form, with interface-name, requires DEFERRED in bind-attr-list,
 // and thus can appear only in an abstract type.
 struct TypeBoundProcedureStmt {
   UNION_CLASS_BOILERPLATE(TypeBoundProcedureStmt);
   struct WithoutInterface {
     BOILERPLATE(WithoutInterface);
     WithoutInterface(
         std::list<BindAttr> &&as, std::list<TypeBoundProcDecl> &&ds)
         : attributes(std::move(as)), declarations(std::move(ds)) {}
     std::list<BindAttr> attributes;
     std::list<TypeBoundProcDecl> declarations;
   };
   struct WithInterface {
     BOILERPLATE(WithInterface);
     WithInterface(Name &&n, std::list<BindAttr> &&as, std::list<Name> &&bs)
         : interfaceName(std::move(n)), attributes(std::move(as)),
           bindingNames(std::move(bs)) {}
     Name interfaceName;
     std::list<BindAttr> attributes;
     std::list<Name> bindingNames;
   };
   std::variant<WithoutInterface, WithInterface> u;
 };
 
 // R751 type-bound-generic-stmt ->
 //        GENERIC [, access-spec] :: generic-spec => binding-name-list
 struct TypeBoundGenericStmt {
   TUPLE_CLASS_BOILERPLATE(TypeBoundGenericStmt);
   std::tuple<std::optional<AccessSpec>, common::Indirection<GenericSpec>,
       std::list<Name>>
       t;
 };
 
 // R753 final-procedure-stmt -> FINAL [::] final-subroutine-name-list
 WRAPPER_CLASS(FinalProcedureStmt, std::list<Name>);
 
 // R748 type-bound-proc-binding ->
 //        type-bound-procedure-stmt | type-bound-generic-stmt |
 //        final-procedure-stmt
 struct TypeBoundProcBinding {
   UNION_CLASS_BOILERPLATE(TypeBoundProcBinding);
   std::variant<TypeBoundProcedureStmt, TypeBoundGenericStmt, FinalProcedureStmt,
       ErrorRecovery>
       u;
 };
 
 // R746 type-bound-procedure-part ->
 //        contains-stmt [binding-private-stmt] [type-bound-proc-binding]...
 struct TypeBoundProcedurePart {
   TUPLE_CLASS_BOILERPLATE(TypeBoundProcedurePart);
   std::tuple<Statement<ContainsStmt>, std::optional<Statement<PrivateStmt>>,
       std::list<Statement<TypeBoundProcBinding>>>
       t;
 };
 
 // R730 end-type-stmt -> END TYPE [type-name]
 WRAPPER_CLASS(EndTypeStmt, std::optional<Name>);
 
 // R726 derived-type-def ->
 //        derived-type-stmt [type-param-def-stmt]... [private-or-sequence]...
 //        [component-part] [type-bound-procedure-part] end-type-stmt
 // R735 component-part -> [component-def-stmt]...
 struct DerivedTypeDef {
   TUPLE_CLASS_BOILERPLATE(DerivedTypeDef);
   std::tuple<Statement<DerivedTypeStmt>, std::list<Statement<TypeParamDefStmt>>,
       std::list<Statement<PrivateOrSequence>>,
       std::list<Statement<ComponentDefStmt>>,
       std::optional<TypeBoundProcedurePart>, Statement<EndTypeStmt>>
       t;
 };
 
 // R758 component-data-source -> expr | data-target | proc-target
 // R1037 data-target -> expr
 // R1040 proc-target -> expr | procedure-name | proc-component-ref
 WRAPPER_CLASS(ComponentDataSource, common::Indirection<Expr>);
 
 // R757 component-spec -> [keyword =] component-data-source
 struct ComponentSpec {
   TUPLE_CLASS_BOILERPLATE(ComponentSpec);
   std::tuple<std::optional<Keyword>, ComponentDataSource> t;
 };
 
 // R756 structure-constructor -> derived-type-spec ( [component-spec-list] )
 struct StructureConstructor {
   TUPLE_CLASS_BOILERPLATE(StructureConstructor);
   std::tuple<DerivedTypeSpec, std::list<ComponentSpec>> t;
 };
 
 // R760 enum-def-stmt -> ENUM, BIND(C)
 EMPTY_CLASS(EnumDefStmt);
 
 // R762 enumerator -> named-constant [= scalar-int-constant-expr]
 struct Enumerator {
   TUPLE_CLASS_BOILERPLATE(Enumerator);
   std::tuple<NamedConstant, std::optional<ScalarIntConstantExpr>> t;
 };
 
 // R761 enumerator-def-stmt -> ENUMERATOR [::] enumerator-list
 WRAPPER_CLASS(EnumeratorDefStmt, std::list<Enumerator>);
 
 // R763 end-enum-stmt -> END ENUM
 EMPTY_CLASS(EndEnumStmt);
 
 // R759 enum-def ->
 //        enum-def-stmt enumerator-def-stmt [enumerator-def-stmt]...
 //        end-enum-stmt
 struct EnumDef {
   TUPLE_CLASS_BOILERPLATE(EnumDef);
   std::tuple<Statement<EnumDefStmt>, std::list<Statement<EnumeratorDefStmt>>,
       Statement<EndEnumStmt>>
       t;
 };
 
 // R773 ac-value -> expr | ac-implied-do
 struct AcValue {
   struct Triplet { // PGI/Intel extension
     TUPLE_CLASS_BOILERPLATE(Triplet);
     std::tuple<ScalarIntExpr, ScalarIntExpr, std::optional<ScalarIntExpr>> t;
   };
   UNION_CLASS_BOILERPLATE(AcValue);
   std::variant<Triplet, common::Indirection<Expr>,
       common::Indirection<AcImpliedDo>>
       u;
 };
 
 // R770 ac-spec -> type-spec :: | [type-spec ::] ac-value-list
 struct AcSpec {
   BOILERPLATE(AcSpec);
   AcSpec(std::optional<TypeSpec> &&ts, std::list<AcValue> &&xs)
       : type(std::move(ts)), values(std::move(xs)) {}
   explicit AcSpec(TypeSpec &&ts) : type{std::move(ts)} {}
   std::optional<TypeSpec> type;
   std::list<AcValue> values;
 };
 
 // R769 array-constructor -> (/ ac-spec /) | lbracket ac-spec rbracket
 WRAPPER_CLASS(ArrayConstructor, AcSpec);
 
 // R1124 do-variable -> scalar-int-variable-name
 using DoVariable = Scalar<Integer<Name>>;
 
 template <typename VAR, typename BOUND> struct LoopBounds {
   LoopBounds(LoopBounds &&that) = default;
   LoopBounds(
       VAR &&name, BOUND &&lower, BOUND &&upper, std::optional<BOUND> &&step)
       : name{std::move(name)}, lower{std::move(lower)}, upper{std::move(upper)},
         step{std::move(step)} {}
   LoopBounds &operator=(LoopBounds &&) = default;
   VAR name;
   BOUND lower, upper;
   std::optional<BOUND> step;
 };
 
 using ScalarName = Scalar<Name>;
 using ScalarExpr = Scalar<common::Indirection<Expr>>;
 
 // R775 ac-implied-do-control ->
 //        [integer-type-spec ::] ac-do-variable = scalar-int-expr ,
 //        scalar-int-expr [, scalar-int-expr]
 // R776 ac-do-variable -> do-variable
 struct AcImpliedDoControl {
   TUPLE_CLASS_BOILERPLATE(AcImpliedDoControl);
   using Bounds = LoopBounds<DoVariable, ScalarIntExpr>;
   std::tuple<std::optional<IntegerTypeSpec>, Bounds> t;
 };
 
 // R774 ac-implied-do -> ( ac-value-list , ac-implied-do-control )
 struct AcImpliedDo {
   TUPLE_CLASS_BOILERPLATE(AcImpliedDo);
   std::tuple<std::list<AcValue>, AcImpliedDoControl> t;
 };
 
 // R808 language-binding-spec ->
 //        BIND ( C [, NAME = scalar-default-char-constant-expr] )
 // R1528 proc-language-binding-spec -> language-binding-spec
 WRAPPER_CLASS(
     LanguageBindingSpec, std::optional<ScalarDefaultCharConstantExpr>);
 
 // R852 named-constant-def -> named-constant = constant-expr
 struct NamedConstantDef {
   TUPLE_CLASS_BOILERPLATE(NamedConstantDef);
   std::tuple<NamedConstant, ConstantExpr> t;
 };
 
 // R851 parameter-stmt -> PARAMETER ( named-constant-def-list )
 WRAPPER_CLASS(ParameterStmt, std::list<NamedConstantDef>);
 
 // R819 assumed-shape-spec -> [lower-bound] :
 WRAPPER_CLASS(AssumedShapeSpec, std::optional<SpecificationExpr>);
 
 // R821 assumed-implied-spec -> [lower-bound :] *
 WRAPPER_CLASS(AssumedImpliedSpec, std::optional<SpecificationExpr>);
 
 // R822 assumed-size-spec -> explicit-shape-spec-list , assumed-implied-spec
 struct AssumedSizeSpec {
   TUPLE_CLASS_BOILERPLATE(AssumedSizeSpec);
   std::tuple<std::list<ExplicitShapeSpec>, AssumedImpliedSpec> t;
 };
 
 // R823 implied-shape-or-assumed-size-spec -> assumed-implied-spec
 // R824 implied-shape-spec -> assumed-implied-spec , assumed-implied-spec-list
 // I.e., when the assumed-implied-spec-list has a single item, it constitutes an
 // implied-shape-or-assumed-size-spec; otherwise, an implied-shape-spec.
 WRAPPER_CLASS(ImpliedShapeSpec, std::list<AssumedImpliedSpec>);
 
 // R825 assumed-rank-spec -> ..
 EMPTY_CLASS(AssumedRankSpec);
 
 // R815 array-spec ->
 //        explicit-shape-spec-list | assumed-shape-spec-list |
 //        deferred-shape-spec-list | assumed-size-spec | implied-shape-spec |
 //        implied-shape-or-assumed-size-spec | assumed-rank-spec
 struct ArraySpec {
   UNION_CLASS_BOILERPLATE(ArraySpec);
   std::variant<std::list<ExplicitShapeSpec>, std::list<AssumedShapeSpec>,
       DeferredShapeSpecList, AssumedSizeSpec, ImpliedShapeSpec, AssumedRankSpec>
       u;
 };
 
 // R826 intent-spec -> IN | OUT | INOUT
 struct IntentSpec {
   ENUM_CLASS(Intent, In, Out, InOut)
   WRAPPER_CLASS_BOILERPLATE(IntentSpec, Intent);
 };
 
 // R802 attr-spec ->
 //        access-spec | ALLOCATABLE | ASYNCHRONOUS |
 //        CODIMENSION lbracket coarray-spec rbracket | CONTIGUOUS |
 //        DIMENSION ( array-spec ) | EXTERNAL | INTENT ( intent-spec ) |
 //        INTRINSIC | language-binding-spec | OPTIONAL | PARAMETER | POINTER |
 //        PROTECTED | SAVE | TARGET | VALUE | VOLATILE
 EMPTY_CLASS(Asynchronous);
 EMPTY_CLASS(External);
 EMPTY_CLASS(Intrinsic);
 EMPTY_CLASS(Optional);
 EMPTY_CLASS(Parameter);
 EMPTY_CLASS(Protected);
 EMPTY_CLASS(Save);
 EMPTY_CLASS(Target);
 EMPTY_CLASS(Value);
 EMPTY_CLASS(Volatile);
 struct AttrSpec {
   UNION_CLASS_BOILERPLATE(AttrSpec);
   std::variant<AccessSpec, Allocatable, Asynchronous, CoarraySpec, Contiguous,
       ArraySpec, External, IntentSpec, Intrinsic, LanguageBindingSpec, Optional,
       Parameter, Pointer, Protected, Save, Target, Value, Volatile>
       u;
 };
 
 // R803 entity-decl ->
 //        object-name [( array-spec )] [lbracket coarray-spec rbracket]
 //          [* char-length] [initialization] |
 //        function-name [* char-length]
 struct EntityDecl {
   TUPLE_CLASS_BOILERPLATE(EntityDecl);
   std::tuple<ObjectName, std::optional<ArraySpec>, std::optional<CoarraySpec>,
       std::optional<CharLength>, std::optional<Initialization>>
       t;
 };
 
 // R801 type-declaration-stmt ->
 //        declaration-type-spec [[, attr-spec]... ::] entity-decl-list
 struct TypeDeclarationStmt {
   TUPLE_CLASS_BOILERPLATE(TypeDeclarationStmt);
   std::tuple<DeclarationTypeSpec, std::list<AttrSpec>, std::list<EntityDecl>> t;
 };
 
 // R828 access-id -> access-name | generic-spec
 struct AccessId {
   UNION_CLASS_BOILERPLATE(AccessId);
   std::variant<Name, common::Indirection<GenericSpec>> u;
 };
 
 // R827 access-stmt -> access-spec [[::] access-id-list]
 struct AccessStmt {
   TUPLE_CLASS_BOILERPLATE(AccessStmt);
   std::tuple<AccessSpec, std::list<AccessId>> t;
 };
 
 // R830 allocatable-decl ->
 //        object-name [( array-spec )] [lbracket coarray-spec rbracket]
 // R860 target-decl ->
 //        object-name [( array-spec )] [lbracket coarray-spec rbracket]
 struct ObjectDecl {
   TUPLE_CLASS_BOILERPLATE(ObjectDecl);
   std::tuple<ObjectName, std::optional<ArraySpec>, std::optional<CoarraySpec>>
       t;
 };
 
 // R829 allocatable-stmt -> ALLOCATABLE [::] allocatable-decl-list
 WRAPPER_CLASS(AllocatableStmt, std::list<ObjectDecl>);
 
 // R831 asynchronous-stmt -> ASYNCHRONOUS [::] object-name-list
 WRAPPER_CLASS(AsynchronousStmt, std::list<ObjectName>);
 
 // R833 bind-entity -> entity-name | / common-block-name /
 struct BindEntity {
   TUPLE_CLASS_BOILERPLATE(BindEntity);
   ENUM_CLASS(Kind, Object, Common)
   std::tuple<Kind, Name> t;
 };
 
 // R832 bind-stmt -> language-binding-spec [::] bind-entity-list
 struct BindStmt {
   TUPLE_CLASS_BOILERPLATE(BindStmt);
   std::tuple<LanguageBindingSpec, std::list<BindEntity>> t;
 };
 
 // R835 codimension-decl -> coarray-name lbracket coarray-spec rbracket
 struct CodimensionDecl {
   TUPLE_CLASS_BOILERPLATE(CodimensionDecl);
   std::tuple<Name, CoarraySpec> t;
 };
 
 // R834 codimension-stmt -> CODIMENSION [::] codimension-decl-list
 WRAPPER_CLASS(CodimensionStmt, std::list<CodimensionDecl>);
 
 // R836 contiguous-stmt -> CONTIGUOUS [::] object-name-list
 WRAPPER_CLASS(ContiguousStmt, std::list<ObjectName>);
 
 // R847 constant-subobject -> designator
 // R846 int-constant-subobject -> constant-subobject
 using ConstantSubobject = Constant<common::Indirection<Designator>>;
 
 // Represents an analyzed expression
 using TypedExpr = common::ForwardOwningPointer<evaluate::GenericExprWrapper>;
 
 // R845 data-stmt-constant ->
 //        scalar-constant | scalar-constant-subobject |
 //        signed-int-literal-constant | signed-real-literal-constant |
 //        null-init | initial-data-target |
 //        constant-structure-constructor    <- added "constant-"
 struct DataStmtConstant {
   UNION_CLASS_BOILERPLATE(DataStmtConstant);
   CharBlock source;
   mutable TypedExpr typedExpr;
   std::variant<Scalar<ConstantValue>, Scalar<ConstantSubobject>,
       SignedIntLiteralConstant, SignedRealLiteralConstant,
       SignedComplexLiteralConstant, NullInit, InitialDataTarget,
       StructureConstructor>
       u;
 };
 
 // R844 data-stmt-repeat -> scalar-int-constant | scalar-int-constant-subobject
 // R607 int-constant -> constant
 // R604 constant -> literal-constant | named-constant
 // (only literal-constant -> int-literal-constant applies)
 struct DataStmtRepeat {
   UNION_CLASS_BOILERPLATE(DataStmtRepeat);
   std::variant<IntLiteralConstant, Scalar<Integer<ConstantSubobject>>> u;
 };
 
 // R843 data-stmt-value -> [data-stmt-repeat *] data-stmt-constant
 struct DataStmtValue {
   TUPLE_CLASS_BOILERPLATE(DataStmtValue);
   mutable std::int64_t repetitions{1}; // replaced during semantics
   std::tuple<std::optional<DataStmtRepeat>, DataStmtConstant> t;
 };
 
 // R841 data-i-do-object ->
 //        array-element | scalar-structure-component | data-implied-do
 struct DataIDoObject {
   UNION_CLASS_BOILERPLATE(DataIDoObject);
   std::variant<Scalar<common::Indirection<Designator>>,
       common::Indirection<DataImpliedDo>>
       u;
 };
 
 // R840 data-implied-do ->
 //        ( data-i-do-object-list , [integer-type-spec ::] data-i-do-variable
 //        = scalar-int-constant-expr , scalar-int-constant-expr
 //        [, scalar-int-constant-expr] )
 // R842 data-i-do-variable -> do-variable
 struct DataImpliedDo {
   TUPLE_CLASS_BOILERPLATE(DataImpliedDo);
   using Bounds = LoopBounds<DoVariable, ScalarIntConstantExpr>;
   std::tuple<std::list<DataIDoObject>, std::optional<IntegerTypeSpec>, Bounds>
       t;
 };
 
 // R839 data-stmt-object -> variable | data-implied-do
 struct DataStmtObject {
   UNION_CLASS_BOILERPLATE(DataStmtObject);
   std::variant<common::Indirection<Variable>, DataImpliedDo> u;
 };
 
 // R838 data-stmt-set -> data-stmt-object-list / data-stmt-value-list /
 struct DataStmtSet {
   TUPLE_CLASS_BOILERPLATE(DataStmtSet);
   std::tuple<std::list<DataStmtObject>, std::list<DataStmtValue>> t;
 };
 
 // R837 data-stmt -> DATA data-stmt-set [[,] data-stmt-set]...
 WRAPPER_CLASS(DataStmt, std::list<DataStmtSet>);
 
 // R848 dimension-stmt ->
 //        DIMENSION [::] array-name ( array-spec )
 //        [, array-name ( array-spec )]...
 struct DimensionStmt {
   struct Declaration {
     TUPLE_CLASS_BOILERPLATE(Declaration);
     std::tuple<Name, ArraySpec> t;
   };
   WRAPPER_CLASS_BOILERPLATE(DimensionStmt, std::list<Declaration>);
 };
 
 // R849 intent-stmt -> INTENT ( intent-spec ) [::] dummy-arg-name-list
 struct IntentStmt {
   TUPLE_CLASS_BOILERPLATE(IntentStmt);
   std::tuple<IntentSpec, std::list<Name>> t;
 };
 
 // R850 optional-stmt -> OPTIONAL [::] dummy-arg-name-list
 WRAPPER_CLASS(OptionalStmt, std::list<Name>);
 
 // R854 pointer-decl ->
 //        object-name [( deferred-shape-spec-list )] | proc-entity-name
 struct PointerDecl {
   TUPLE_CLASS_BOILERPLATE(PointerDecl);
   std::tuple<Name, std::optional<DeferredShapeSpecList>> t;
 };
 
 // R853 pointer-stmt -> POINTER [::] pointer-decl-list
 WRAPPER_CLASS(PointerStmt, std::list<PointerDecl>);
 
 // R855 protected-stmt -> PROTECTED [::] entity-name-list
 WRAPPER_CLASS(ProtectedStmt, std::list<Name>);
 
 // R857 saved-entity -> object-name | proc-pointer-name | / common-block-name /
 // R858 proc-pointer-name -> name
 struct SavedEntity {
   TUPLE_CLASS_BOILERPLATE(SavedEntity);
   ENUM_CLASS(Kind, Entity, Common)
   std::tuple<Kind, Name> t;
 };
 
 // R856 save-stmt -> SAVE [[::] saved-entity-list]
 WRAPPER_CLASS(SaveStmt, std::list<SavedEntity>);
 
 // R859 target-stmt -> TARGET [::] target-decl-list
 WRAPPER_CLASS(TargetStmt, std::list<ObjectDecl>);
 
 // R861 value-stmt -> VALUE [::] dummy-arg-name-list
 WRAPPER_CLASS(ValueStmt, std::list<Name>);
 
 // R862 volatile-stmt -> VOLATILE [::] object-name-list
 WRAPPER_CLASS(VolatileStmt, std::list<ObjectName>);
 
 // R865 letter-spec -> letter [- letter]
 struct LetterSpec {
   TUPLE_CLASS_BOILERPLATE(LetterSpec);
   std::tuple<Location, std::optional<Location>> t;
 };
 
 // R864 implicit-spec -> declaration-type-spec ( letter-spec-list )
 struct ImplicitSpec {
   TUPLE_CLASS_BOILERPLATE(ImplicitSpec);
   std::tuple<DeclarationTypeSpec, std::list<LetterSpec>> t;
 };
 
 // R863 implicit-stmt ->
 //        IMPLICIT implicit-spec-list |
 //        IMPLICIT NONE [( [implicit-name-spec-list] )]
 // R866 implicit-name-spec -> EXTERNAL | TYPE
 struct ImplicitStmt {
   UNION_CLASS_BOILERPLATE(ImplicitStmt);
   ENUM_CLASS(ImplicitNoneNameSpec, External, Type) // R866
   std::variant<std::list<ImplicitSpec>, std::list<ImplicitNoneNameSpec>> u;
 };
 
 // R874 common-block-object -> variable-name [( array-spec )]
 struct CommonBlockObject {
   TUPLE_CLASS_BOILERPLATE(CommonBlockObject);
   std::tuple<Name, std::optional<ArraySpec>> t;
 };
 
 // R873 common-stmt ->
 //        COMMON [/ [common-block-name] /] common-block-object-list
 //        [[,] / [common-block-name] / common-block-object-list]...
 struct CommonStmt {
   struct Block {
     TUPLE_CLASS_BOILERPLATE(Block);
     std::tuple<std::optional<Name>, std::list<CommonBlockObject>> t;
   };
   BOILERPLATE(CommonStmt);
   CommonStmt(std::optional<Name> &&, std::list<CommonBlockObject> &&,
       std::list<Block> &&);
   std::list<Block> blocks;
 };
 
 // R872 equivalence-object -> variable-name | array-element | substring
 WRAPPER_CLASS(EquivalenceObject, common::Indirection<Designator>);
 
 // R870 equivalence-stmt -> EQUIVALENCE equivalence-set-list
 // R871 equivalence-set -> ( equivalence-object , equivalence-object-list )
 WRAPPER_CLASS(EquivalenceStmt, std::list<std::list<EquivalenceObject>>);
 
 // R910 substring-range -> [scalar-int-expr] : [scalar-int-expr]
 struct SubstringRange {
   TUPLE_CLASS_BOILERPLATE(SubstringRange);
   std::tuple<std::optional<ScalarIntExpr>, std::optional<ScalarIntExpr>> t;
 };
 
 // R919 subscript -> scalar-int-expr
 using Subscript = ScalarIntExpr;
 
 // R921 subscript-triplet -> [subscript] : [subscript] [: stride]
 struct SubscriptTriplet {
   TUPLE_CLASS_BOILERPLATE(SubscriptTriplet);
   std::tuple<std::optional<Subscript>, std::optional<Subscript>,
       std::optional<Subscript>>
       t;
 };
 
 // R920 section-subscript -> subscript | subscript-triplet | vector-subscript
 // R923 vector-subscript -> int-expr
 struct SectionSubscript {
   UNION_CLASS_BOILERPLATE(SectionSubscript);
   std::variant<IntExpr, SubscriptTriplet> u;
 };
 
 // R925 cosubscript -> scalar-int-expr
 using Cosubscript = ScalarIntExpr;
 
 // R1115 team-value -> scalar-expr
 WRAPPER_CLASS(TeamValue, Scalar<common::Indirection<Expr>>);
 
 // R926 image-selector-spec ->
 //        STAT = stat-variable | TEAM = team-value |
 //        TEAM_NUMBER = scalar-int-expr
 struct ImageSelectorSpec {
   WRAPPER_CLASS(Stat, Scalar<Integer<common::Indirection<Variable>>>);
   WRAPPER_CLASS(Team_Number, ScalarIntExpr);
   UNION_CLASS_BOILERPLATE(ImageSelectorSpec);
   std::variant<Stat, TeamValue, Team_Number> u;
 };
 
 // R924 image-selector ->
 //        lbracket cosubscript-list [, image-selector-spec-list] rbracket
 struct ImageSelector {
   TUPLE_CLASS_BOILERPLATE(ImageSelector);
   std::tuple<std::list<Cosubscript>, std::list<ImageSelectorSpec>> t;
 };
 
 // R1001 - R1022 expressions
 struct Expr {
   UNION_CLASS_BOILERPLATE(Expr);
 
   WRAPPER_CLASS(IntrinsicUnary, common::Indirection<Expr>);
   struct Parentheses : public IntrinsicUnary {
     using IntrinsicUnary::IntrinsicUnary;
   };
   struct UnaryPlus : public IntrinsicUnary {
     using IntrinsicUnary::IntrinsicUnary;
   };
   struct Negate : public IntrinsicUnary {
     using IntrinsicUnary::IntrinsicUnary;
   };
   struct NOT : public IntrinsicUnary {
     using IntrinsicUnary::IntrinsicUnary;
   };
 
   WRAPPER_CLASS(PercentLoc, common::Indirection<Variable>); // %LOC(v) extension
 
   struct DefinedUnary {
     TUPLE_CLASS_BOILERPLATE(DefinedUnary);
     std::tuple<DefinedOpName, common::Indirection<Expr>> t;
   };
 
   struct IntrinsicBinary {
     TUPLE_CLASS_BOILERPLATE(IntrinsicBinary);
     std::tuple<common::Indirection<Expr>, common::Indirection<Expr>> t;
   };
   struct Power : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct Multiply : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct Divide : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct Add : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct Subtract : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct Concat : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct LT : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct LE : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct EQ : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct NE : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct GE : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct GT : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct AND : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct OR : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct EQV : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct NEQV : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
 
   // PGI/XLF extension: (x,y), not both constant
   struct ComplexConstructor : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
 
   struct DefinedBinary {
     TUPLE_CLASS_BOILERPLATE(DefinedBinary);
     std::tuple<DefinedOpName, common::Indirection<Expr>,
         common::Indirection<Expr>>
         t;
   };
 
   explicit Expr(Designator &&);
   explicit Expr(FunctionReference &&);
 
   mutable TypedExpr typedExpr;
 
   CharBlock source;
 
   std::variant<common::Indirection<CharLiteralConstantSubstring>,
       LiteralConstant, common::Indirection<Designator>, ArrayConstructor,
       StructureConstructor, common::Indirection<FunctionReference>, Parentheses,
       UnaryPlus, Negate, NOT, PercentLoc, DefinedUnary, Power, Multiply, Divide,
       Add, Subtract, Concat, LT, LE, EQ, NE, GE, GT, AND, OR, EQV, NEQV,
       DefinedBinary, ComplexConstructor>
       u;
 };
 
 // R912 part-ref -> part-name [( section-subscript-list )] [image-selector]
 struct PartRef {
   BOILERPLATE(PartRef);
   PartRef(Name &&n, std::list<SectionSubscript> &&ss,
       std::optional<ImageSelector> &&is)
       : name{std::move(n)},
         subscripts(std::move(ss)), imageSelector{std::move(is)} {}
   Name name;
   std::list<SectionSubscript> subscripts;
   std::optional<ImageSelector> imageSelector;
 };
 
 // R911 data-ref -> part-ref [% part-ref]...
 struct DataRef {
   UNION_CLASS_BOILERPLATE(DataRef);
   explicit DataRef(std::list<PartRef> &&);
   std::variant<Name, common::Indirection<StructureComponent>,
       common::Indirection<ArrayElement>,
       common::Indirection<CoindexedNamedObject>>
       u;
 };
 
 // R908 substring -> parent-string ( substring-range )
 // R909 parent-string ->
 //        scalar-variable-name | array-element | coindexed-named-object |
 //        scalar-structure-component | scalar-char-literal-constant |
 //        scalar-named-constant
 // Substrings of character literals have been factored out into their
 // own productions so that they can't appear as designators in any context
 // other than a primary expression.
 struct Substring {
   TUPLE_CLASS_BOILERPLATE(Substring);
   std::tuple<DataRef, SubstringRange> t;
 };
 
 struct CharLiteralConstantSubstring {
   TUPLE_CLASS_BOILERPLATE(CharLiteralConstantSubstring);
   std::tuple<CharLiteralConstant, SubstringRange> t;
 };
 
 // R901 designator -> object-name | array-element | array-section |
 //                    coindexed-named-object | complex-part-designator |
 //                    structure-component | substring
 struct Designator {
   UNION_CLASS_BOILERPLATE(Designator);
   bool EndsInBareName() const;
   CharBlock source;
   std::variant<DataRef, Substring> u;
 };
 
 // R902 variable -> designator | function-reference
 struct Variable {
   UNION_CLASS_BOILERPLATE(Variable);
   mutable TypedExpr typedExpr;
   parser::CharBlock GetSource() const;
   std::variant<common::Indirection<Designator>,
       common::Indirection<FunctionReference>>
       u;
 };
 
 // R904 logical-variable -> variable
 // Appears only as part of scalar-logical-variable.
 using ScalarLogicalVariable = Scalar<Logical<Variable>>;
 
 // R906 default-char-variable -> variable
 // Appears only as part of scalar-default-char-variable.
 using ScalarDefaultCharVariable = Scalar<DefaultChar<Variable>>;
 
 // R907 int-variable -> variable
 // Appears only as part of scalar-int-variable.
 using ScalarIntVariable = Scalar<Integer<Variable>>;
 
 // R913 structure-component -> data-ref
 struct StructureComponent {
   BOILERPLATE(StructureComponent);
   StructureComponent(DataRef &&dr, Name &&n)
       : base{std::move(dr)}, component(std::move(n)) {}
   DataRef base;
   Name component;
 };
 
 // R1039 proc-component-ref -> scalar-variable % procedure-component-name
 // C1027 constrains the scalar-variable to be a data-ref without coindices.
 struct ProcComponentRef {
   WRAPPER_CLASS_BOILERPLATE(ProcComponentRef, Scalar<StructureComponent>);
 };
 
 // R914 coindexed-named-object -> data-ref
 struct CoindexedNamedObject {
   BOILERPLATE(CoindexedNamedObject);
   CoindexedNamedObject(DataRef &&dr, ImageSelector &&is)
       : base{std::move(dr)}, imageSelector{std::move(is)} {}
   DataRef base;
   ImageSelector imageSelector;
 };
 
 // R917 array-element -> data-ref
 struct ArrayElement {
   BOILERPLATE(ArrayElement);
   ArrayElement(DataRef &&dr, std::list<SectionSubscript> &&ss)
       : base{std::move(dr)}, subscripts(std::move(ss)) {}
   Substring ConvertToSubstring();
   StructureConstructor ConvertToStructureConstructor(
       const semantics::DerivedTypeSpec &);
   DataRef base;
   std::list<SectionSubscript> subscripts;
 };
 
 // R933 allocate-object -> variable-name | structure-component
 struct AllocateObject {
   UNION_CLASS_BOILERPLATE(AllocateObject);
   std::variant<Name, StructureComponent> u;
 };
 
 // R935 lower-bound-expr -> scalar-int-expr
 // R936 upper-bound-expr -> scalar-int-expr
 using BoundExpr = ScalarIntExpr;
 
 // R934 allocate-shape-spec -> [lower-bound-expr :] upper-bound-expr
 // R938 allocate-coshape-spec -> [lower-bound-expr :] upper-bound-expr
 struct AllocateShapeSpec {
   TUPLE_CLASS_BOILERPLATE(AllocateShapeSpec);
   std::tuple<std::optional<BoundExpr>, BoundExpr> t;
 };
 
 using AllocateCoshapeSpec = AllocateShapeSpec;
 
 // R937 allocate-coarray-spec ->
 //      [allocate-coshape-spec-list ,] [lower-bound-expr :] *
 struct AllocateCoarraySpec {
   TUPLE_CLASS_BOILERPLATE(AllocateCoarraySpec);
   std::tuple<std::list<AllocateCoshapeSpec>, std::optional<BoundExpr>> t;
 };
 
 // R932 allocation ->
 //        allocate-object [( allocate-shape-spec-list )]
 //        [lbracket allocate-coarray-spec rbracket]
 struct Allocation {
   TUPLE_CLASS_BOILERPLATE(Allocation);
   std::tuple<AllocateObject, std::list<AllocateShapeSpec>,
       std::optional<AllocateCoarraySpec>>
       t;
 };
 
 // R929 stat-variable -> scalar-int-variable
 WRAPPER_CLASS(StatVariable, ScalarIntVariable);
 
 // R930 errmsg-variable -> scalar-default-char-variable
 // R1207 iomsg-variable -> scalar-default-char-variable
 WRAPPER_CLASS(MsgVariable, ScalarDefaultCharVariable);
 
 // R942 dealloc-opt -> STAT = stat-variable | ERRMSG = errmsg-variable
 // R1165 sync-stat -> STAT = stat-variable | ERRMSG = errmsg-variable
 struct StatOrErrmsg {
   UNION_CLASS_BOILERPLATE(StatOrErrmsg);
   std::variant<StatVariable, MsgVariable> u;
 };
 
 // R928 alloc-opt ->
 //        ERRMSG = errmsg-variable | MOLD = source-expr |
 //        SOURCE = source-expr | STAT = stat-variable
 // R931 source-expr -> expr
 struct AllocOpt {
   UNION_CLASS_BOILERPLATE(AllocOpt);
   WRAPPER_CLASS(Mold, common::Indirection<Expr>);
   WRAPPER_CLASS(Source, common::Indirection<Expr>);
   std::variant<Mold, Source, StatOrErrmsg> u;
 };
 
 // R927 allocate-stmt ->
 //        ALLOCATE ( [type-spec ::] allocation-list [, alloc-opt-list] )
 struct AllocateStmt {
   TUPLE_CLASS_BOILERPLATE(AllocateStmt);
   std::tuple<std::optional<TypeSpec>, std::list<Allocation>,
       std::list<AllocOpt>>
       t;
 };
 
 // R940 pointer-object ->
 //        variable-name | structure-component | proc-pointer-name
 struct PointerObject {
   UNION_CLASS_BOILERPLATE(PointerObject);
   std::variant<Name, StructureComponent> u;
 };
 
 // R939 nullify-stmt -> NULLIFY ( pointer-object-list )
 WRAPPER_CLASS(NullifyStmt, std::list<PointerObject>);
 
 // R941 deallocate-stmt ->
 //        DEALLOCATE ( allocate-object-list [, dealloc-opt-list] )
 struct DeallocateStmt {
   TUPLE_CLASS_BOILERPLATE(DeallocateStmt);
   std::tuple<std::list<AllocateObject>, std::list<StatOrErrmsg>> t;
 };
 
 // R1032 assignment-stmt -> variable = expr
 struct AssignmentStmt {
   TUPLE_CLASS_BOILERPLATE(AssignmentStmt);
   using TypedAssignment =
       common::ForwardOwningPointer<evaluate::GenericAssignmentWrapper>;
   mutable TypedAssignment typedAssignment;
   std::tuple<Variable, Expr> t;
 };
 
 // R1035 bounds-spec -> lower-bound-expr :
 WRAPPER_CLASS(BoundsSpec, BoundExpr);
 
 // R1036 bounds-remapping -> lower-bound-expr : upper-bound-expr
 struct BoundsRemapping {
   TUPLE_CLASS_BOILERPLATE(BoundsRemapping);
   std::tuple<BoundExpr, BoundExpr> t;
 };
 
 // R1033 pointer-assignment-stmt ->
 //         data-pointer-object [( bounds-spec-list )] => data-target |
 //         data-pointer-object ( bounds-remapping-list ) => data-target |
 //         proc-pointer-object => proc-target
 // R1034 data-pointer-object ->
 //         variable-name | scalar-variable % data-pointer-component-name
 // R1038 proc-pointer-object -> proc-pointer-name | proc-component-ref
 struct PointerAssignmentStmt {
   struct Bounds {
     UNION_CLASS_BOILERPLATE(Bounds);
     std::variant<std::list<BoundsRemapping>, std::list<BoundsSpec>> u;
   };
   TUPLE_CLASS_BOILERPLATE(PointerAssignmentStmt);
   mutable AssignmentStmt::TypedAssignment typedAssignment;
   std::tuple<DataRef, Bounds, Expr> t;
 };
 
 // R1041 where-stmt -> WHERE ( mask-expr ) where-assignment-stmt
 // R1045 where-assignment-stmt -> assignment-stmt
 // R1046 mask-expr -> logical-expr
 struct WhereStmt {
   TUPLE_CLASS_BOILERPLATE(WhereStmt);
   std::tuple<LogicalExpr, AssignmentStmt> t;
 };
 
 // R1043 where-construct-stmt -> [where-construct-name :] WHERE ( mask-expr )
 struct WhereConstructStmt {
   TUPLE_CLASS_BOILERPLATE(WhereConstructStmt);
   std::tuple<std::optional<Name>, LogicalExpr> t;
 };
 
 // R1044 where-body-construct ->
 //         where-assignment-stmt | where-stmt | where-construct
 struct WhereBodyConstruct {
   UNION_CLASS_BOILERPLATE(WhereBodyConstruct);
   std::variant<Statement<AssignmentStmt>, Statement<WhereStmt>,
       common::Indirection<WhereConstruct>>
       u;
 };
 
 // R1047 masked-elsewhere-stmt ->
 //         ELSEWHERE ( mask-expr ) [where-construct-name]
 struct MaskedElsewhereStmt {
   TUPLE_CLASS_BOILERPLATE(MaskedElsewhereStmt);
   std::tuple<LogicalExpr, std::optional<Name>> t;
 };
 
 // R1048 elsewhere-stmt -> ELSEWHERE [where-construct-name]
 WRAPPER_CLASS(ElsewhereStmt, std::optional<Name>);
 
 // R1049 end-where-stmt -> END WHERE [where-construct-name]
 WRAPPER_CLASS(EndWhereStmt, std::optional<Name>);
 
 // R1042 where-construct ->
 //         where-construct-stmt [where-body-construct]...
 //         [masked-elsewhere-stmt [where-body-construct]...]...
 //         [elsewhere-stmt [where-body-construct]...] end-where-stmt
 struct WhereConstruct {
   struct MaskedElsewhere {
     TUPLE_CLASS_BOILERPLATE(MaskedElsewhere);
     std::tuple<Statement<MaskedElsewhereStmt>, std::list<WhereBodyConstruct>> t;
   };
   struct Elsewhere {
     TUPLE_CLASS_BOILERPLATE(Elsewhere);
     std::tuple<Statement<ElsewhereStmt>, std::list<WhereBodyConstruct>> t;
   };
   TUPLE_CLASS_BOILERPLATE(WhereConstruct);
   std::tuple<Statement<WhereConstructStmt>, std::list<WhereBodyConstruct>,
       std::list<MaskedElsewhere>, std::optional<Elsewhere>,
       Statement<EndWhereStmt>>
       t;
 };
 
 // R1051 forall-construct-stmt ->
 //         [forall-construct-name :] FORALL concurrent-header
 struct ForallConstructStmt {
   TUPLE_CLASS_BOILERPLATE(ForallConstructStmt);
   std::tuple<std::optional<Name>, common::Indirection<ConcurrentHeader>> t;
 };
 
 // R1053 forall-assignment-stmt -> assignment-stmt | pointer-assignment-stmt
 struct ForallAssignmentStmt {
   UNION_CLASS_BOILERPLATE(ForallAssignmentStmt);
   std::variant<AssignmentStmt, PointerAssignmentStmt> u;
 };
 
 // R1055 forall-stmt -> FORALL concurrent-header forall-assignment-stmt
 struct ForallStmt {
   TUPLE_CLASS_BOILERPLATE(ForallStmt);
   std::tuple<common::Indirection<ConcurrentHeader>,
       UnlabeledStatement<ForallAssignmentStmt>>
       t;
 };
 
 // R1052 forall-body-construct ->
 //         forall-assignment-stmt | where-stmt | where-construct |
 //         forall-construct | forall-stmt
 struct ForallBodyConstruct {
   UNION_CLASS_BOILERPLATE(ForallBodyConstruct);
   std::variant<Statement<ForallAssignmentStmt>, Statement<WhereStmt>,
       WhereConstruct, common::Indirection<ForallConstruct>,
       Statement<ForallStmt>>
       u;
 };
 
 // R1054 end-forall-stmt -> END FORALL [forall-construct-name]
 WRAPPER_CLASS(EndForallStmt, std::optional<Name>);
 
 // R1050 forall-construct ->
 //         forall-construct-stmt [forall-body-construct]... end-forall-stmt
 struct ForallConstruct {
   TUPLE_CLASS_BOILERPLATE(ForallConstruct);
   std::tuple<Statement<ForallConstructStmt>, std::list<ForallBodyConstruct>,
       Statement<EndForallStmt>>
       t;
 };
 
 // R1101 block -> [execution-part-construct]...
 using Block = std::list<ExecutionPartConstruct>;
 
 // R1105 selector -> expr | variable
 struct Selector {
   UNION_CLASS_BOILERPLATE(Selector);
   std::variant<Expr, Variable> u;
 };
 
 // R1104 association -> associate-name => selector
 struct Association {
   TUPLE_CLASS_BOILERPLATE(Association);
   std::tuple<Name, Selector> t;
 };
 
 // R1103 associate-stmt ->
 //        [associate-construct-name :] ASSOCIATE ( association-list )
 struct AssociateStmt {
   TUPLE_CLASS_BOILERPLATE(AssociateStmt);
   std::tuple<std::optional<Name>, std::list<Association>> t;
 };
 
 // R1106 end-associate-stmt -> END ASSOCIATE [associate-construct-name]
 WRAPPER_CLASS(EndAssociateStmt, std::optional<Name>);
 
 // R1102 associate-construct -> associate-stmt block end-associate-stmt
 struct AssociateConstruct {
   TUPLE_CLASS_BOILERPLATE(AssociateConstruct);
   std::tuple<Statement<AssociateStmt>, Block, Statement<EndAssociateStmt>> t;
 };
 
 // R1108 block-stmt -> [block-construct-name :] BLOCK
 WRAPPER_CLASS(BlockStmt, std::optional<Name>);
 
 // R1110 end-block-stmt -> END BLOCK [block-construct-name]
 WRAPPER_CLASS(EndBlockStmt, std::optional<Name>);
 
 // R1109 block-specification-part ->
 //         [use-stmt]... [import-stmt]...
 //         [[declaration-construct]... specification-construct]
 WRAPPER_CLASS(BlockSpecificationPart, SpecificationPart);
 // TODO: Because BlockSpecificationPart just wraps the more general
 // SpecificationPart, it can misrecognize an ImplicitPart as part of
 // the BlockSpecificationPart during parsing, and we have to detect and
 // flag such usage in semantics.
 
 // R1107 block-construct ->
 //         block-stmt [block-specification-part] block end-block-stmt
 struct BlockConstruct {
   TUPLE_CLASS_BOILERPLATE(BlockConstruct);
   std::tuple<Statement<BlockStmt>, BlockSpecificationPart, Block,
       Statement<EndBlockStmt>>
       t;
 };
 
 // R1113 coarray-association -> codimension-decl => selector
 struct CoarrayAssociation {
   TUPLE_CLASS_BOILERPLATE(CoarrayAssociation);
   std::tuple<CodimensionDecl, Selector> t;
 };
 
 // R1112 change-team-stmt ->
 //         [team-construct-name :] CHANGE TEAM
 //         ( team-value [, coarray-association-list] [, sync-stat-list] )
 struct ChangeTeamStmt {
   TUPLE_CLASS_BOILERPLATE(ChangeTeamStmt);
   std::tuple<std::optional<Name>, TeamValue, std::list<CoarrayAssociation>,
       std::list<StatOrErrmsg>>
       t;
 };
 
 // R1114 end-change-team-stmt ->
 //         END TEAM [( [sync-stat-list] )] [team-construct-name]
 struct EndChangeTeamStmt {
   TUPLE_CLASS_BOILERPLATE(EndChangeTeamStmt);
   std::tuple<std::list<StatOrErrmsg>, std::optional<Name>> t;
 };
 
 // R1111 change-team-construct -> change-team-stmt block end-change-team-stmt
 struct ChangeTeamConstruct {
   TUPLE_CLASS_BOILERPLATE(ChangeTeamConstruct);
   std::tuple<Statement<ChangeTeamStmt>, Block, Statement<EndChangeTeamStmt>> t;
 };
 
 // R1117 critical-stmt ->
 //         [critical-construct-name :] CRITICAL [( [sync-stat-list] )]
 struct CriticalStmt {
   TUPLE_CLASS_BOILERPLATE(CriticalStmt);
   std::tuple<std::optional<Name>, std::list<StatOrErrmsg>> t;
 };
 
 // R1118 end-critical-stmt -> END CRITICAL [critical-construct-name]
 WRAPPER_CLASS(EndCriticalStmt, std::optional<Name>);
 
 // R1116 critical-construct -> critical-stmt block end-critical-stmt
 struct CriticalConstruct {
   TUPLE_CLASS_BOILERPLATE(CriticalConstruct);
   std::tuple<Statement<CriticalStmt>, Block, Statement<EndCriticalStmt>> t;
 };
 
 // R1126 concurrent-control ->
 //         index-name = concurrent-limit : concurrent-limit [: concurrent-step]
 // R1127 concurrent-limit -> scalar-int-expr
 // R1128 concurrent-step -> scalar-int-expr
 struct ConcurrentControl {
   TUPLE_CLASS_BOILERPLATE(ConcurrentControl);
   std::tuple<Name, ScalarIntExpr, ScalarIntExpr, std::optional<ScalarIntExpr>>
       t;
 };
 
 // R1125 concurrent-header ->
 //         ( [integer-type-spec ::] concurrent-control-list
 //         [, scalar-mask-expr] )
 struct ConcurrentHeader {
   TUPLE_CLASS_BOILERPLATE(ConcurrentHeader);
   std::tuple<std::optional<IntegerTypeSpec>, std::list<ConcurrentControl>,
       std::optional<ScalarLogicalExpr>>
       t;
 };
 
 // R1130 locality-spec ->
 //         LOCAL ( variable-name-list ) | LOCAL_INIT ( variable-name-list ) |
 //         SHARED ( variable-name-list ) | DEFAULT ( NONE )
 struct LocalitySpec {
   UNION_CLASS_BOILERPLATE(LocalitySpec);
   WRAPPER_CLASS(Local, std::list<Name>);
   WRAPPER_CLASS(LocalInit, std::list<Name>);
   WRAPPER_CLASS(Shared, std::list<Name>);
   EMPTY_CLASS(DefaultNone);
   std::variant<Local, LocalInit, Shared, DefaultNone> u;
 };
 
 // R1123 loop-control ->
 //         [,] do-variable = scalar-int-expr , scalar-int-expr
 //           [, scalar-int-expr] |
 //         [,] WHILE ( scalar-logical-expr ) |
 //         [,] CONCURRENT concurrent-header concurrent-locality
 // R1129 concurrent-locality -> [locality-spec]...
 struct LoopControl {
   UNION_CLASS_BOILERPLATE(LoopControl);
   struct Concurrent {
     TUPLE_CLASS_BOILERPLATE(Concurrent);
     std::tuple<ConcurrentHeader, std::list<LocalitySpec>> t;
   };
   using Bounds = LoopBounds<ScalarName, ScalarExpr>;
   std::variant<Bounds, ScalarLogicalExpr, Concurrent> u;
 };
 
 // R1121 label-do-stmt -> [do-construct-name :] DO label [loop-control]
 struct LabelDoStmt {
   TUPLE_CLASS_BOILERPLATE(LabelDoStmt);
   std::tuple<std::optional<Name>, Label, std::optional<LoopControl>> t;
 };
 
 // R1122 nonlabel-do-stmt -> [do-construct-name :] DO [loop-control]
 struct NonLabelDoStmt {
   TUPLE_CLASS_BOILERPLATE(NonLabelDoStmt);
   std::tuple<std::optional<Name>, std::optional<LoopControl>> t;
 };
 
 // R1132 end-do-stmt -> END DO [do-construct-name]
 WRAPPER_CLASS(EndDoStmt, std::optional<Name>);
 
 // R1131 end-do -> end-do-stmt | continue-stmt
 
 // R1119 do-construct -> do-stmt block end-do
 // R1120 do-stmt -> nonlabel-do-stmt | label-do-stmt
 // TODO: deprecated: DO loop ending on statement types other than END DO and
 // CONTINUE; multiple "label DO" loops ending on the same label
 struct DoConstruct {
   TUPLE_CLASS_BOILERPLATE(DoConstruct);
   const std::optional<LoopControl> &GetLoopControl() const;
   bool IsDoNormal() const;
   bool IsDoWhile() const;
   bool IsDoConcurrent() const;
   std::tuple<Statement<NonLabelDoStmt>, Block, Statement<EndDoStmt>> t;
 };
 
 // R1133 cycle-stmt -> CYCLE [do-construct-name]
 WRAPPER_CLASS(CycleStmt, std::optional<Name>);
 
 // R1135 if-then-stmt -> [if-construct-name :] IF ( scalar-logical-expr ) THEN
 struct IfThenStmt {
   TUPLE_CLASS_BOILERPLATE(IfThenStmt);
   std::tuple<std::optional<Name>, ScalarLogicalExpr> t;
 };
 
 // R1136 else-if-stmt ->
 //         ELSE IF ( scalar-logical-expr ) THEN [if-construct-name]
 struct ElseIfStmt {
   TUPLE_CLASS_BOILERPLATE(ElseIfStmt);
   std::tuple<ScalarLogicalExpr, std::optional<Name>> t;
 };
 
 // R1137 else-stmt -> ELSE [if-construct-name]
 WRAPPER_CLASS(ElseStmt, std::optional<Name>);
 
 // R1138 end-if-stmt -> END IF [if-construct-name]
 WRAPPER_CLASS(EndIfStmt, std::optional<Name>);
 
 // R1134 if-construct ->
 //         if-then-stmt block [else-if-stmt block]...
 //         [else-stmt block] end-if-stmt
 struct IfConstruct {
   struct ElseIfBlock {
     TUPLE_CLASS_BOILERPLATE(ElseIfBlock);
     std::tuple<Statement<ElseIfStmt>, Block> t;
   };
   struct ElseBlock {
     TUPLE_CLASS_BOILERPLATE(ElseBlock);
     std::tuple<Statement<ElseStmt>, Block> t;
   };
   TUPLE_CLASS_BOILERPLATE(IfConstruct);
   std::tuple<Statement<IfThenStmt>, Block, std::list<ElseIfBlock>,
       std::optional<ElseBlock>, Statement<EndIfStmt>>
       t;
 };
 
 // R1139 if-stmt -> IF ( scalar-logical-expr ) action-stmt
 struct IfStmt {
   TUPLE_CLASS_BOILERPLATE(IfStmt);
   std::tuple<ScalarLogicalExpr, UnlabeledStatement<ActionStmt>> t;
 };
 
 // R1141 select-case-stmt -> [case-construct-name :] SELECT CASE ( case-expr )
 // R1144 case-expr -> scalar-expr
 struct SelectCaseStmt {
   TUPLE_CLASS_BOILERPLATE(SelectCaseStmt);
   std::tuple<std::optional<Name>, Scalar<Expr>> t;
 };
 
 // R1147 case-value -> scalar-constant-expr
 using CaseValue = Scalar<ConstantExpr>;
 
 // R1146 case-value-range ->
 //         case-value | case-value : | : case-value | case-value : case-value
 struct CaseValueRange {
   UNION_CLASS_BOILERPLATE(CaseValueRange);
   struct Range {
     BOILERPLATE(Range);
     Range(std::optional<CaseValue> &&l, std::optional<CaseValue> &&u)
         : lower{std::move(l)}, upper{std::move(u)} {}
     std::optional<CaseValue> lower, upper; // not both missing
   };
   std::variant<CaseValue, Range> u;
 };
 
 // R1145 case-selector -> ( case-value-range-list ) | DEFAULT
 EMPTY_CLASS(Default);
 
 struct CaseSelector {
   UNION_CLASS_BOILERPLATE(CaseSelector);
   std::variant<std::list<CaseValueRange>, Default> u;
 };
 
 // R1142 case-stmt -> CASE case-selector [case-construct-name]
 struct CaseStmt {
   TUPLE_CLASS_BOILERPLATE(CaseStmt);
   std::tuple<CaseSelector, std::optional<Name>> t;
 };
 
 // R1143 end-select-stmt -> END SELECT [case-construct-name]
 // R1151 end-select-rank-stmt -> END SELECT [select-construct-name]
 // R1155 end-select-type-stmt -> END SELECT [select-construct-name]
 WRAPPER_CLASS(EndSelectStmt, std::optional<Name>);
 
 // R1140 case-construct ->
 //         select-case-stmt [case-stmt block]... end-select-stmt
 struct CaseConstruct {
   struct Case {
     TUPLE_CLASS_BOILERPLATE(Case);
     std::tuple<Statement<CaseStmt>, Block> t;
   };
   TUPLE_CLASS_BOILERPLATE(CaseConstruct);
   std::tuple<Statement<SelectCaseStmt>, std::list<Case>,
       Statement<EndSelectStmt>>
       t;
 };
 
 // R1149 select-rank-stmt ->
 //         [select-construct-name :] SELECT RANK
 //         ( [associate-name =>] selector )
 struct SelectRankStmt {
   TUPLE_CLASS_BOILERPLATE(SelectRankStmt);
   std::tuple<std::optional<Name>, std::optional<Name>, Selector> t;
 };
 
 // R1150 select-rank-case-stmt ->
 //         RANK ( scalar-int-constant-expr ) [select-construct-name] |
 //         RANK ( * ) [select-construct-name] |
 //         RANK DEFAULT [select-construct-name]
 struct SelectRankCaseStmt {
   struct Rank {
     UNION_CLASS_BOILERPLATE(Rank);
     std::variant<ScalarIntConstantExpr, Star, Default> u;
   };
   TUPLE_CLASS_BOILERPLATE(SelectRankCaseStmt);
   std::tuple<Rank, std::optional<Name>> t;
 };
 
 // R1148 select-rank-construct ->
 //         select-rank-stmt [select-rank-case-stmt block]...
 //         end-select-rank-stmt
 struct SelectRankConstruct {
   TUPLE_CLASS_BOILERPLATE(SelectRankConstruct);
   struct RankCase {
     TUPLE_CLASS_BOILERPLATE(RankCase);
     std::tuple<Statement<SelectRankCaseStmt>, Block> t;
   };
   std::tuple<Statement<SelectRankStmt>, std::list<RankCase>,
       Statement<EndSelectStmt>>
       t;
 };
 
 // R1153 select-type-stmt ->
 //         [select-construct-name :] SELECT TYPE
 //         ( [associate-name =>] selector )
 struct SelectTypeStmt {
   TUPLE_CLASS_BOILERPLATE(SelectTypeStmt);
   std::tuple<std::optional<Name>, std::optional<Name>, Selector> t;
 };
 
 // R1154 type-guard-stmt ->
 //         TYPE IS ( type-spec ) [select-construct-name] |
 //         CLASS IS ( derived-type-spec ) [select-construct-name] |
 //         CLASS DEFAULT [select-construct-name]
 struct TypeGuardStmt {
   struct Guard {
     UNION_CLASS_BOILERPLATE(Guard);
     std::variant<TypeSpec, DerivedTypeSpec, Default> u;
   };
   TUPLE_CLASS_BOILERPLATE(TypeGuardStmt);
   std::tuple<Guard, std::optional<Name>> t;
 };
 
 // R1152 select-type-construct ->
 //         select-type-stmt [type-guard-stmt block]... end-select-type-stmt
 struct SelectTypeConstruct {
   TUPLE_CLASS_BOILERPLATE(SelectTypeConstruct);
   struct TypeCase {
     TUPLE_CLASS_BOILERPLATE(TypeCase);
     std::tuple<Statement<TypeGuardStmt>, Block> t;
   };
   std::tuple<Statement<SelectTypeStmt>, std::list<TypeCase>,
       Statement<EndSelectStmt>>
       t;
 };
 
 // R1156 exit-stmt -> EXIT [construct-name]
 WRAPPER_CLASS(ExitStmt, std::optional<Name>);
 
 // R1157 goto-stmt -> GO TO label
 WRAPPER_CLASS(GotoStmt, Label);
 
 // R1158 computed-goto-stmt -> GO TO ( label-list ) [,] scalar-int-expr
 struct ComputedGotoStmt {
   TUPLE_CLASS_BOILERPLATE(ComputedGotoStmt);
   std::tuple<std::list<Label>, ScalarIntExpr> t;
 };
 
 // R1162 stop-code -> scalar-default-char-expr | scalar-int-expr
 // We can't distinguish character expressions from integer
 // expressions during parsing, so we just parse an expr and
 // check its type later.
 WRAPPER_CLASS(StopCode, Scalar<Expr>);
 
 // R1160 stop-stmt -> STOP [stop-code] [, QUIET = scalar-logical-expr]
 // R1161 error-stop-stmt ->
 //         ERROR STOP [stop-code] [, QUIET = scalar-logical-expr]
 struct StopStmt {
   ENUM_CLASS(Kind, Stop, ErrorStop)
   TUPLE_CLASS_BOILERPLATE(StopStmt);
   std::tuple<Kind, std::optional<StopCode>, std::optional<ScalarLogicalExpr>> t;
 };
 
 // R1164 sync-all-stmt -> SYNC ALL [( [sync-stat-list] )]
 WRAPPER_CLASS(SyncAllStmt, std::list<StatOrErrmsg>);
 
 // R1166 sync-images-stmt -> SYNC IMAGES ( image-set [, sync-stat-list] )
 // R1167 image-set -> int-expr | *
 struct SyncImagesStmt {
   struct ImageSet {
     UNION_CLASS_BOILERPLATE(ImageSet);
     std::variant<IntExpr, Star> u;
   };
   TUPLE_CLASS_BOILERPLATE(SyncImagesStmt);
   std::tuple<ImageSet, std::list<StatOrErrmsg>> t;
 };
 
 // R1168 sync-memory-stmt -> SYNC MEMORY [( [sync-stat-list] )]
 WRAPPER_CLASS(SyncMemoryStmt, std::list<StatOrErrmsg>);
 
 // R1169 sync-team-stmt -> SYNC TEAM ( team-value [, sync-stat-list] )
 struct SyncTeamStmt {
   TUPLE_CLASS_BOILERPLATE(SyncTeamStmt);
   std::tuple<TeamValue, std::list<StatOrErrmsg>> t;
 };
 
 // R1171 event-variable -> scalar-variable
 using EventVariable = Scalar<Variable>;
 
 // R1170 event-post-stmt -> EVENT POST ( event-variable [, sync-stat-list] )
 struct EventPostStmt {
   TUPLE_CLASS_BOILERPLATE(EventPostStmt);
   std::tuple<EventVariable, std::list<StatOrErrmsg>> t;
 };
 
 // R1172 event-wait-stmt ->
 //         EVENT WAIT ( event-variable [, event-wait-spec-list] )
 // R1173 event-wait-spec -> until-spec | sync-stat
 // R1174 until-spec -> UNTIL_COUNT = scalar-int-expr
 struct EventWaitStmt {
   struct EventWaitSpec {
     UNION_CLASS_BOILERPLATE(EventWaitSpec);
     std::variant<ScalarIntExpr, StatOrErrmsg> u;
   };
   TUPLE_CLASS_BOILERPLATE(EventWaitStmt);
   std::tuple<EventVariable, std::list<EventWaitSpec>> t;
 };
 
 // R1177 team-variable -> scalar-variable
 using TeamVariable = Scalar<Variable>;
 
 // R1175 form-team-stmt ->
 //         FORM TEAM ( team-number , team-variable [, form-team-spec-list] )
 // R1176 team-number -> scalar-int-expr
 // R1178 form-team-spec -> NEW_INDEX = scalar-int-expr | sync-stat
 struct FormTeamStmt {
   struct FormTeamSpec {
     UNION_CLASS_BOILERPLATE(FormTeamSpec);
     std::variant<ScalarIntExpr, StatOrErrmsg> u;
   };
   TUPLE_CLASS_BOILERPLATE(FormTeamStmt);
   std::tuple<ScalarIntExpr, TeamVariable, std::list<FormTeamSpec>> t;
 };
 
 // R1182 lock-variable -> scalar-variable
 using LockVariable = Scalar<Variable>;
 
 // R1179 lock-stmt -> LOCK ( lock-variable [, lock-stat-list] )
 // R1180 lock-stat -> ACQUIRED_LOCK = scalar-logical-variable | sync-stat
 struct LockStmt {
   struct LockStat {
     UNION_CLASS_BOILERPLATE(LockStat);
     std::variant<Scalar<Logical<Variable>>, StatOrErrmsg> u;
   };
   TUPLE_CLASS_BOILERPLATE(LockStmt);
   std::tuple<LockVariable, std::list<LockStat>> t;
 };
 
 // R1181 unlock-stmt -> UNLOCK ( lock-variable [, sync-stat-list] )
 struct UnlockStmt {
   TUPLE_CLASS_BOILERPLATE(UnlockStmt);
   std::tuple<LockVariable, std::list<StatOrErrmsg>> t;
 };
 
 // R1202 file-unit-number -> scalar-int-expr
 WRAPPER_CLASS(FileUnitNumber, ScalarIntExpr);
 
 // R1201 io-unit -> file-unit-number | * | internal-file-variable
 // R1203 internal-file-variable -> char-variable
 // R905 char-variable -> variable
 // When Variable appears as an IoUnit, it must be character of a default,
 // ASCII, or Unicode kind; this constraint is not automatically checked.
 // The parse is ambiguous and is repaired if necessary once the types of
 // symbols are known.
 struct IoUnit {
   UNION_CLASS_BOILERPLATE(IoUnit);
   std::variant<Variable, FileUnitNumber, Star> u;
 };
 
 // R1206 file-name-expr -> scalar-default-char-expr
 using FileNameExpr = ScalarDefaultCharExpr;
 
 // R1205 connect-spec ->
 //         [UNIT =] file-unit-number | ACCESS = scalar-default-char-expr |
 //         ACTION = scalar-default-char-expr |
 //         ASYNCHRONOUS = scalar-default-char-expr |
 //         BLANK = scalar-default-char-expr |
 //         DECIMAL = scalar-default-char-expr |
 //         DELIM = scalar-default-char-expr |
 //         ENCODING = scalar-default-char-expr | ERR = label |
 //         FILE = file-name-expr | FORM = scalar-default-char-expr |
 //         IOMSG = iomsg-variable | IOSTAT = scalar-int-variable |
 //         NEWUNIT = scalar-int-variable | PAD = scalar-default-char-expr |
 //         POSITION = scalar-default-char-expr | RECL = scalar-int-expr |
 //         ROUND = scalar-default-char-expr | SIGN = scalar-default-char-expr |
 //         STATUS = scalar-default-char-expr
 //         @ | CONVERT = scalar-default-char-variable
 //           | DISPOSE = scalar-default-char-variable
 WRAPPER_CLASS(StatusExpr, ScalarDefaultCharExpr);
 WRAPPER_CLASS(ErrLabel, Label);
 
 struct ConnectSpec {
   UNION_CLASS_BOILERPLATE(ConnectSpec);
   struct CharExpr {
     ENUM_CLASS(Kind, Access, Action, Asynchronous, Blank, Decimal, Delim,
         Encoding, Form, Pad, Position, Round, Sign,
         /* extensions: */ Convert, Dispose)
     TUPLE_CLASS_BOILERPLATE(CharExpr);
     std::tuple<Kind, ScalarDefaultCharExpr> t;
   };
   WRAPPER_CLASS(Recl, ScalarIntExpr);
   WRAPPER_CLASS(Newunit, ScalarIntVariable);
   std::variant<FileUnitNumber, FileNameExpr, CharExpr, MsgVariable,
       StatVariable, Recl, Newunit, ErrLabel, StatusExpr>
       u;
 };
 
 // R1204 open-stmt -> OPEN ( connect-spec-list )
 WRAPPER_CLASS(OpenStmt, std::list<ConnectSpec>);
 
 // R1208 close-stmt -> CLOSE ( close-spec-list )
 // R1209 close-spec ->
 //         [UNIT =] file-unit-number | IOSTAT = scalar-int-variable |
 //         IOMSG = iomsg-variable | ERR = label |
 //         STATUS = scalar-default-char-expr
 struct CloseStmt {
   struct CloseSpec {
     UNION_CLASS_BOILERPLATE(CloseSpec);
     std::variant<FileUnitNumber, StatVariable, MsgVariable, ErrLabel,
         StatusExpr>
         u;
   };
   WRAPPER_CLASS_BOILERPLATE(CloseStmt, std::list<CloseSpec>);
 };
 
 // R1215 format -> default-char-expr | label | *
 // deprecated(ASSIGN): | scalar-int-name
 struct Format {
   UNION_CLASS_BOILERPLATE(Format);
   std::variant<Expr, Label, Star> u;
 };
 
 // R1214 id-variable -> scalar-int-variable
 WRAPPER_CLASS(IdVariable, ScalarIntVariable);
 
 // R1213 io-control-spec ->
 //         [UNIT =] io-unit | [FMT =] format | [NML =] namelist-group-name |
 //         ADVANCE = scalar-default-char-expr |
 //         ASYNCHRONOUS = scalar-default-char-constant-expr |
 //         BLANK = scalar-default-char-expr |
 //         DECIMAL = scalar-default-char-expr |
 //         DELIM = scalar-default-char-expr | END = label | EOR = label |
 //         ERR = label | ID = id-variable | IOMSG = iomsg-variable |
 //         IOSTAT = scalar-int-variable | PAD = scalar-default-char-expr |
 //         POS = scalar-int-expr | REC = scalar-int-expr |
 //         ROUND = scalar-default-char-expr | SIGN = scalar-default-char-expr |
 //         SIZE = scalar-int-variable
 WRAPPER_CLASS(EndLabel, Label);
 WRAPPER_CLASS(EorLabel, Label);
 struct IoControlSpec {
   UNION_CLASS_BOILERPLATE(IoControlSpec);
   struct CharExpr {
     ENUM_CLASS(Kind, Advance, Blank, Decimal, Delim, Pad, Round, Sign)
     TUPLE_CLASS_BOILERPLATE(CharExpr);
     std::tuple<Kind, ScalarDefaultCharExpr> t;
   };
   WRAPPER_CLASS(Asynchronous, ScalarDefaultCharConstantExpr);
   WRAPPER_CLASS(Pos, ScalarIntExpr);
   WRAPPER_CLASS(Rec, ScalarIntExpr);
   WRAPPER_CLASS(Size, ScalarIntVariable);
   std::variant<IoUnit, Format, Name, CharExpr, Asynchronous, EndLabel, EorLabel,
       ErrLabel, IdVariable, MsgVariable, StatVariable, Pos, Rec, Size>
       u;
 };
 
 // R1216 input-item -> variable | io-implied-do
 struct InputItem {
   UNION_CLASS_BOILERPLATE(InputItem);
   std::variant<Variable, common::Indirection<InputImpliedDo>> u;
 };
 
 // R1210 read-stmt ->
 //         READ ( io-control-spec-list ) [input-item-list] |
 //         READ format [, input-item-list]
 struct ReadStmt {
   BOILERPLATE(ReadStmt);
   ReadStmt(std::optional<IoUnit> &&i, std::optional<Format> &&f,
       std::list<IoControlSpec> &&cs, std::list<InputItem> &&its)
       : iounit{std::move(i)}, format{std::move(f)}, controls(std::move(cs)),
         items(std::move(its)) {}
   std::optional<IoUnit> iounit; // if first in controls without UNIT= &/or
                                 // followed by untagged format/namelist
   std::optional<Format> format; // if second in controls without FMT=/NML=, or
                                 // no (io-control-spec-list); might be
                                 // an untagged namelist group name
   std::list<IoControlSpec> controls;
   std::list<InputItem> items;
 };
 
 // R1217 output-item -> expr | io-implied-do
 struct OutputItem {
   UNION_CLASS_BOILERPLATE(OutputItem);
   std::variant<Expr, common::Indirection<OutputImpliedDo>> u;
 };
 
 // R1211 write-stmt -> WRITE ( io-control-spec-list ) [output-item-list]
 struct WriteStmt {
   BOILERPLATE(WriteStmt);
   WriteStmt(std::optional<IoUnit> &&i, std::optional<Format> &&f,
       std::list<IoControlSpec> &&cs, std::list<OutputItem> &&its)
       : iounit{std::move(i)}, format{std::move(f)}, controls(std::move(cs)),
         items(std::move(its)) {}
   std::optional<IoUnit> iounit; // if first in controls without UNIT= &/or
                                 // followed by untagged format/namelist
   std::optional<Format> format; // if second in controls without FMT=/NML=;
                                 // might be an untagged namelist group, too
   std::list<IoControlSpec> controls;
   std::list<OutputItem> items;
 };
 
 // R1212 print-stmt PRINT format [, output-item-list]
 struct PrintStmt {
   TUPLE_CLASS_BOILERPLATE(PrintStmt);
   std::tuple<Format, std::list<OutputItem>> t;
 };
 
 // R1220 io-implied-do-control ->
 //         do-variable = scalar-int-expr , scalar-int-expr [, scalar-int-expr]
 using IoImpliedDoControl = LoopBounds<DoVariable, ScalarIntExpr>;
 
 // R1218 io-implied-do -> ( io-implied-do-object-list , io-implied-do-control )
 // R1219 io-implied-do-object -> input-item | output-item
 struct InputImpliedDo {
   TUPLE_CLASS_BOILERPLATE(InputImpliedDo);
   std::tuple<std::list<InputItem>, IoImpliedDoControl> t;
 };
 
 struct OutputImpliedDo {
   TUPLE_CLASS_BOILERPLATE(OutputImpliedDo);
   std::tuple<std::list<OutputItem>, IoImpliedDoControl> t;
 };
 
 // R1223 wait-spec ->
 //         [UNIT =] file-unit-number | END = label | EOR = label | ERR = label |
 //         ID = scalar-int-expr | IOMSG = iomsg-variable |
 //         IOSTAT = scalar-int-variable
 WRAPPER_CLASS(IdExpr, ScalarIntExpr);
 struct WaitSpec {
   UNION_CLASS_BOILERPLATE(WaitSpec);
   std::variant<FileUnitNumber, EndLabel, EorLabel, ErrLabel, IdExpr,
       MsgVariable, StatVariable>
       u;
 };
 
 // R1222 wait-stmt -> WAIT ( wait-spec-list )
 WRAPPER_CLASS(WaitStmt, std::list<WaitSpec>);
 
 // R1227 position-spec ->
 //         [UNIT =] file-unit-number | IOMSG = iomsg-variable |
 //         IOSTAT = scalar-int-variable | ERR = label
 // R1229 flush-spec ->
 //         [UNIT =] file-unit-number | IOSTAT = scalar-int-variable |
 //         IOMSG = iomsg-variable | ERR = label
 struct PositionOrFlushSpec {
   UNION_CLASS_BOILERPLATE(PositionOrFlushSpec);
   std::variant<FileUnitNumber, MsgVariable, StatVariable, ErrLabel> u;
 };
 
 // R1224 backspace-stmt ->
 //         BACKSPACE file-unit-number | BACKSPACE ( position-spec-list )
 WRAPPER_CLASS(BackspaceStmt, std::list<PositionOrFlushSpec>);
 
 // R1225 endfile-stmt ->
 //         ENDFILE file-unit-number | ENDFILE ( position-spec-list )
 WRAPPER_CLASS(EndfileStmt, std::list<PositionOrFlushSpec>);
 
 // R1226 rewind-stmt -> REWIND file-unit-number | REWIND ( position-spec-list )
 WRAPPER_CLASS(RewindStmt, std::list<PositionOrFlushSpec>);
 
 // R1228 flush-stmt -> FLUSH file-unit-number | FLUSH ( flush-spec-list )
 WRAPPER_CLASS(FlushStmt, std::list<PositionOrFlushSpec>);
 
 // R1231 inquire-spec ->
 //         [UNIT =] file-unit-number | FILE = file-name-expr |
 //         ACCESS = scalar-default-char-variable |
 //         ACTION = scalar-default-char-variable |
 //         ASYNCHRONOUS = scalar-default-char-variable |
 //         BLANK = scalar-default-char-variable |
 //         DECIMAL = scalar-default-char-variable |
 //         DELIM = scalar-default-char-variable |
 //         DIRECT = scalar-default-char-variable |
 //         ENCODING = scalar-default-char-variable |
 //         ERR = label | EXIST = scalar-logical-variable |
 //         FORM = scalar-default-char-variable |
 //         FORMATTED = scalar-default-char-variable |
 //         ID = scalar-int-expr | IOMSG = iomsg-variable |
 //         IOSTAT = scalar-int-variable |
 //         NAME = scalar-default-char-variable |
 //         NAMED = scalar-logical-variable |
 //         NEXTREC = scalar-int-variable | NUMBER = scalar-int-variable |
 //         OPENED = scalar-logical-variable |
 //         PAD = scalar-default-char-variable |
 //         PENDING = scalar-logical-variable | POS = scalar-int-variable |
 //         POSITION = scalar-default-char-variable |
 //         READ = scalar-default-char-variable |
 //         READWRITE = scalar-default-char-variable |
 //         RECL = scalar-int-variable | ROUND = scalar-default-char-variable |
 //         SEQUENTIAL = scalar-default-char-variable |
 //         SIGN = scalar-default-char-variable |
 //         SIZE = scalar-int-variable |
 //         STREAM = scalar-default-char-variable |
 //         STATUS = scalar-default-char-variable |
 //         UNFORMATTED = scalar-default-char-variable |
 //         WRITE = scalar-default-char-variable
 //         @ | CONVERT = scalar-default-char-variable
 //           | DISPOSE = scalar-default-char-variable
 struct InquireSpec {
   UNION_CLASS_BOILERPLATE(InquireSpec);
   struct CharVar {
     ENUM_CLASS(Kind, Access, Action, Asynchronous, Blank, Decimal, Delim,
         Direct, Encoding, Form, Formatted, Iomsg, Name, Pad, Position, Read,
         Readwrite, Round, Sequential, Sign, Stream, Status, Unformatted, Write,
         /* extensions: */ Convert, Dispose)
     TUPLE_CLASS_BOILERPLATE(CharVar);
     std::tuple<Kind, ScalarDefaultCharVariable> t;
   };
   struct IntVar {
     ENUM_CLASS(Kind, Iostat, Nextrec, Number, Pos, Recl, Size)
     TUPLE_CLASS_BOILERPLATE(IntVar);
     std::tuple<Kind, ScalarIntVariable> t;
   };
   struct LogVar {
     ENUM_CLASS(Kind, Exist, Named, Opened, Pending)
     TUPLE_CLASS_BOILERPLATE(LogVar);
     std::tuple<Kind, Scalar<Logical<Variable>>> t;
   };
   std::variant<FileUnitNumber, FileNameExpr, CharVar, IntVar, LogVar, IdExpr,
       ErrLabel>
       u;
 };
 
 // R1230 inquire-stmt ->
 //         INQUIRE ( inquire-spec-list ) |
 //         INQUIRE ( IOLENGTH = scalar-int-variable ) output-item-list
 struct InquireStmt {
   UNION_CLASS_BOILERPLATE(InquireStmt);
   struct Iolength {
     TUPLE_CLASS_BOILERPLATE(Iolength);
     std::tuple<ScalarIntVariable, std::list<OutputItem>> t;
   };
   std::variant<std::list<InquireSpec>, Iolength> u;
 };
 
 // R1301 format-stmt -> FORMAT format-specification
 WRAPPER_CLASS(FormatStmt, format::FormatSpecification);
 
 // R1402 program-stmt -> PROGRAM program-name
 WRAPPER_CLASS(ProgramStmt, Name);
 
 // R1403 end-program-stmt -> END [PROGRAM [program-name]]
 WRAPPER_CLASS(EndProgramStmt, std::optional<Name>);
 
 // R1401 main-program ->
 //         [program-stmt] [specification-part] [execution-part]
 //         [internal-subprogram-part] end-program-stmt
 struct MainProgram {
   TUPLE_CLASS_BOILERPLATE(MainProgram);
   std::tuple<std::optional<Statement<ProgramStmt>>, SpecificationPart,
       ExecutionPart, std::optional<InternalSubprogramPart>,
       Statement<EndProgramStmt>>
       t;
 };
 
 // R1405 module-stmt -> MODULE module-name
 WRAPPER_CLASS(ModuleStmt, Name);
 
 // R1408 module-subprogram ->
 //         function-subprogram | subroutine-subprogram |
 //         separate-module-subprogram
 struct ModuleSubprogram {
   UNION_CLASS_BOILERPLATE(ModuleSubprogram);
   std::variant<common::Indirection<FunctionSubprogram>,
       common::Indirection<SubroutineSubprogram>,
       common::Indirection<SeparateModuleSubprogram>>
       u;
 };
 
 // R1407 module-subprogram-part -> contains-stmt [module-subprogram]...
 struct ModuleSubprogramPart {
   TUPLE_CLASS_BOILERPLATE(ModuleSubprogramPart);
   std::tuple<Statement<ContainsStmt>, std::list<ModuleSubprogram>> t;
 };
 
 // R1406 end-module-stmt -> END [MODULE [module-name]]
 WRAPPER_CLASS(EndModuleStmt, std::optional<Name>);
 
 // R1404 module ->
 //         module-stmt [specification-part] [module-subprogram-part]
 //         end-module-stmt
 struct Module {
   TUPLE_CLASS_BOILERPLATE(Module);
   std::tuple<Statement<ModuleStmt>, SpecificationPart,
       std::optional<ModuleSubprogramPart>, Statement<EndModuleStmt>>
       t;
 };
 
 // R1411 rename ->
 //         local-name => use-name |
 //         OPERATOR ( local-defined-operator ) =>
 //           OPERATOR ( use-defined-operator )
 struct Rename {
   UNION_CLASS_BOILERPLATE(Rename);
   struct Names {
     TUPLE_CLASS_BOILERPLATE(Names);
     std::tuple<Name, Name> t;
   };
   struct Operators {
     TUPLE_CLASS_BOILERPLATE(Operators);
     std::tuple<DefinedOpName, DefinedOpName> t;
   };
   std::variant<Names, Operators> u;
 };
 
 // R1418 parent-identifier -> ancestor-module-name [: parent-submodule-name]
 struct ParentIdentifier {
   TUPLE_CLASS_BOILERPLATE(ParentIdentifier);
   std::tuple<Name, std::optional<Name>> t;
 };
 
 // R1417 submodule-stmt -> SUBMODULE ( parent-identifier ) submodule-name
 struct SubmoduleStmt {
   TUPLE_CLASS_BOILERPLATE(SubmoduleStmt);
   std::tuple<ParentIdentifier, Name> t;
 };
 
 // R1419 end-submodule-stmt -> END [SUBMODULE [submodule-name]]
 WRAPPER_CLASS(EndSubmoduleStmt, std::optional<Name>);
 
 // R1416 submodule ->
 //         submodule-stmt [specification-part] [module-subprogram-part]
 //         end-submodule-stmt
 struct Submodule {
   TUPLE_CLASS_BOILERPLATE(Submodule);
   std::tuple<Statement<SubmoduleStmt>, SpecificationPart,
       std::optional<ModuleSubprogramPart>, Statement<EndSubmoduleStmt>>
       t;
 };
 
 // R1421 block-data-stmt -> BLOCK DATA [block-data-name]
 WRAPPER_CLASS(BlockDataStmt, std::optional<Name>);
 
 // R1422 end-block-data-stmt -> END [BLOCK DATA [block-data-name]]
 WRAPPER_CLASS(EndBlockDataStmt, std::optional<Name>);
 
 // R1420 block-data -> block-data-stmt [specification-part] end-block-data-stmt
 struct BlockData {
   TUPLE_CLASS_BOILERPLATE(BlockData);
   std::tuple<Statement<BlockDataStmt>, SpecificationPart,
       Statement<EndBlockDataStmt>>
       t;
 };
 
 // R1508 generic-spec ->
 //         generic-name | OPERATOR ( defined-operator ) |
 //         ASSIGNMENT ( = ) | defined-io-generic-spec
 // R1509 defined-io-generic-spec ->
 //         READ ( FORMATTED ) | READ ( UNFORMATTED ) |
 //         WRITE ( FORMATTED ) | WRITE ( UNFORMATTED )
 struct GenericSpec {
   UNION_CLASS_BOILERPLATE(GenericSpec);
   EMPTY_CLASS(Assignment);
   EMPTY_CLASS(ReadFormatted);
   EMPTY_CLASS(ReadUnformatted);
   EMPTY_CLASS(WriteFormatted);
   EMPTY_CLASS(WriteUnformatted);
   CharBlock source;
   std::variant<Name, DefinedOperator, Assignment, ReadFormatted,
       ReadUnformatted, WriteFormatted, WriteUnformatted>
       u;
 };
 
 // R1510 generic-stmt ->
 //         GENERIC [, access-spec] :: generic-spec => specific-procedure-list
 struct GenericStmt {
   TUPLE_CLASS_BOILERPLATE(GenericStmt);
   std::tuple<std::optional<AccessSpec>, GenericSpec, std::list<Name>> t;
 };
 
 // R1503 interface-stmt -> INTERFACE [generic-spec] | ABSTRACT INTERFACE
 struct InterfaceStmt {
   UNION_CLASS_BOILERPLATE(InterfaceStmt);
   // Workaround for clang with libstc++10 bug
   InterfaceStmt(Abstract x) : u{x} {}
 
   std::variant<std::optional<GenericSpec>, Abstract> u;
 };
 
 // R1412 only -> generic-spec | only-use-name | rename
 // R1413 only-use-name -> use-name
 struct Only {
   UNION_CLASS_BOILERPLATE(Only);
   std::variant<common::Indirection<GenericSpec>, Name, Rename> u;
 };
 
 // R1409 use-stmt ->
 //         USE [[, module-nature] ::] module-name [, rename-list] |
 //         USE [[, module-nature] ::] module-name , ONLY : [only-list]
 // R1410 module-nature -> INTRINSIC | NON_INTRINSIC
 struct UseStmt {
   BOILERPLATE(UseStmt);
   ENUM_CLASS(ModuleNature, Intrinsic, Non_Intrinsic) // R1410
   template <typename A>
   UseStmt(std::optional<ModuleNature> &&nat, Name &&n, std::list<A> &&x)
       : nature(std::move(nat)), moduleName(std::move(n)), u(std::move(x)) {}
   std::optional<ModuleNature> nature;
   Name moduleName;
   std::variant<std::list<Rename>, std::list<Only>> u;
 };
 
 // R1514 proc-attr-spec ->
 //         access-spec | proc-language-binding-spec | INTENT ( intent-spec ) |
 //         OPTIONAL | POINTER | PROTECTED | SAVE
 struct ProcAttrSpec {
   UNION_CLASS_BOILERPLATE(ProcAttrSpec);
   std::variant<AccessSpec, LanguageBindingSpec, IntentSpec, Optional, Pointer,
       Protected, Save>
       u;
 };
 
 // R1512 procedure-declaration-stmt ->
 //         PROCEDURE ( [proc-interface] ) [[, proc-attr-spec]... ::]
 //         proc-decl-list
 struct ProcedureDeclarationStmt {
   TUPLE_CLASS_BOILERPLATE(ProcedureDeclarationStmt);
   std::tuple<std::optional<ProcInterface>, std::list<ProcAttrSpec>,
       std::list<ProcDecl>>
       t;
 };
 
 // R1527 prefix-spec ->
 //         declaration-type-spec | ELEMENTAL | IMPURE | MODULE |
 //         NON_RECURSIVE | PURE | RECURSIVE
 struct PrefixSpec {
   UNION_CLASS_BOILERPLATE(PrefixSpec);
   EMPTY_CLASS(Elemental);
   EMPTY_CLASS(Impure);
   EMPTY_CLASS(Module);
   EMPTY_CLASS(Non_Recursive);
   EMPTY_CLASS(Pure);
   EMPTY_CLASS(Recursive);
   std::variant<DeclarationTypeSpec, Elemental, Impure, Module, Non_Recursive,
       Pure, Recursive>
       u;
 };
 
 // R1532 suffix ->
 //         proc-language-binding-spec [RESULT ( result-name )] |
 //         RESULT ( result-name ) [proc-language-binding-spec]
 struct Suffix {
   BOILERPLATE(Suffix);
   Suffix(LanguageBindingSpec &&lbs, std::optional<Name> &&rn)
       : binding(std::move(lbs)), resultName(std::move(rn)) {}
   Suffix(Name &&rn, std::optional<LanguageBindingSpec> &&lbs)
       : binding(std::move(lbs)), resultName(std::move(rn)) {}
   std::optional<LanguageBindingSpec> binding;
   std::optional<Name> resultName;
 };
 
 // R1530 function-stmt ->
 //         [prefix] FUNCTION function-name ( [dummy-arg-name-list] ) [suffix]
 // R1526 prefix -> prefix-spec [prefix-spec]...
 // R1531 dummy-arg-name -> name
 struct FunctionStmt {
   TUPLE_CLASS_BOILERPLATE(FunctionStmt);
   std::tuple<std::list<PrefixSpec>, Name, std::list<Name>,
       std::optional<Suffix>>
       t;
 };
 
 // R1533 end-function-stmt -> END [FUNCTION [function-name]]
 WRAPPER_CLASS(EndFunctionStmt, std::optional<Name>);
 
 // R1536 dummy-arg -> dummy-arg-name | *
 struct DummyArg {
   UNION_CLASS_BOILERPLATE(DummyArg);
   std::variant<Name, Star> u;
 };
 
 // R1535 subroutine-stmt ->
 //         [prefix] SUBROUTINE subroutine-name [( [dummy-arg-list] )
 //         [proc-language-binding-spec]]
 struct SubroutineStmt {
   TUPLE_CLASS_BOILERPLATE(SubroutineStmt);
   std::tuple<std::list<PrefixSpec>, Name, std::list<DummyArg>,
       std::optional<LanguageBindingSpec>>
       t;
 };
 
 // R1537 end-subroutine-stmt -> END [SUBROUTINE [subroutine-name]]
 WRAPPER_CLASS(EndSubroutineStmt, std::optional<Name>);
 
 // R1505 interface-body ->
 //         function-stmt [specification-part] end-function-stmt |
 //         subroutine-stmt [specification-part] end-subroutine-stmt
 struct InterfaceBody {
   UNION_CLASS_BOILERPLATE(InterfaceBody);
   struct Function {
     TUPLE_CLASS_BOILERPLATE(Function);
     std::tuple<Statement<FunctionStmt>, common::Indirection<SpecificationPart>,
         Statement<EndFunctionStmt>>
         t;
   };
   struct Subroutine {
     TUPLE_CLASS_BOILERPLATE(Subroutine);
     std::tuple<Statement<SubroutineStmt>,
         common::Indirection<SpecificationPart>, Statement<EndSubroutineStmt>>
         t;
   };
   std::variant<Function, Subroutine> u;
 };
 
 // R1506 procedure-stmt -> [MODULE] PROCEDURE [::] specific-procedure-list
 struct ProcedureStmt {
   ENUM_CLASS(Kind, ModuleProcedure, Procedure)
   TUPLE_CLASS_BOILERPLATE(ProcedureStmt);
   std::tuple<Kind, std::list<Name>> t;
 };
 
 // R1502 interface-specification -> interface-body | procedure-stmt
 struct InterfaceSpecification {
   UNION_CLASS_BOILERPLATE(InterfaceSpecification);
   std::variant<InterfaceBody, Statement<ProcedureStmt>> u;
 };
 
 // R1504 end-interface-stmt -> END INTERFACE [generic-spec]
 WRAPPER_CLASS(EndInterfaceStmt, std::optional<GenericSpec>);
 
 // R1501 interface-block ->
 //         interface-stmt [interface-specification]... end-interface-stmt
 struct InterfaceBlock {
   TUPLE_CLASS_BOILERPLATE(InterfaceBlock);
   std::tuple<Statement<InterfaceStmt>, std::list<InterfaceSpecification>,
       Statement<EndInterfaceStmt>>
       t;
 };
 
 // R1511 external-stmt -> EXTERNAL [::] external-name-list
 WRAPPER_CLASS(ExternalStmt, std::list<Name>);
 
 // R1519 intrinsic-stmt -> INTRINSIC [::] intrinsic-procedure-name-list
 WRAPPER_CLASS(IntrinsicStmt, std::list<Name>);
 
 // R1522 procedure-designator ->
 //         procedure-name | proc-component-ref | data-ref % binding-name
 struct ProcedureDesignator {
   UNION_CLASS_BOILERPLATE(ProcedureDesignator);
   std::variant<Name, ProcComponentRef> u;
 };
 
 // R1525 alt-return-spec -> * label
 WRAPPER_CLASS(AltReturnSpec, Label);
 
 // R1524 actual-arg ->
 //         expr | variable | procedure-name | proc-component-ref |
 //         alt-return-spec
 struct ActualArg {
   WRAPPER_CLASS(PercentRef, Variable); // %REF(v) extension
   WRAPPER_CLASS(PercentVal, Expr); // %VAL(x) extension
   UNION_CLASS_BOILERPLATE(ActualArg);
   ActualArg(Expr &&x) : u{common::Indirection<Expr>(std::move(x))} {}
   std::variant<common::Indirection<Expr>, AltReturnSpec, PercentRef, PercentVal>
       u;
 };
 
 // R1523 actual-arg-spec -> [keyword =] actual-arg
 struct ActualArgSpec {
   TUPLE_CLASS_BOILERPLATE(ActualArgSpec);
   std::tuple<std::optional<Keyword>, ActualArg> t;
 };
 
 // R1520 function-reference -> procedure-designator ( [actual-arg-spec-list] )
 struct Call {
   TUPLE_CLASS_BOILERPLATE(Call);
   CharBlock source;
   std::tuple<ProcedureDesignator, std::list<ActualArgSpec>> t;
 };
 
 struct FunctionReference {
   WRAPPER_CLASS_BOILERPLATE(FunctionReference, Call);
   Designator ConvertToArrayElementRef();
   StructureConstructor ConvertToStructureConstructor(
       const semantics::DerivedTypeSpec &);
 };
 
 // R1521 call-stmt -> CALL procedure-designator [( [actual-arg-spec-list] )]
 struct CallStmt {
   WRAPPER_CLASS_BOILERPLATE(CallStmt, Call);
   mutable common::ForwardOwningPointer<evaluate::ProcedureRef>
       typedCall; // filled by semantics
 };
 
 // R1529 function-subprogram ->
 //         function-stmt [specification-part] [execution-part]
 //         [internal-subprogram-part] end-function-stmt
 struct FunctionSubprogram {
   TUPLE_CLASS_BOILERPLATE(FunctionSubprogram);
   std::tuple<Statement<FunctionStmt>, SpecificationPart, ExecutionPart,
       std::optional<InternalSubprogramPart>, Statement<EndFunctionStmt>>
       t;
 };
 
 // R1534 subroutine-subprogram ->
 //         subroutine-stmt [specification-part] [execution-part]
 //         [internal-subprogram-part] end-subroutine-stmt
 struct SubroutineSubprogram {
   TUPLE_CLASS_BOILERPLATE(SubroutineSubprogram);
   std::tuple<Statement<SubroutineStmt>, SpecificationPart, ExecutionPart,
       std::optional<InternalSubprogramPart>, Statement<EndSubroutineStmt>>
       t;
 };
 
 // R1539 mp-subprogram-stmt -> MODULE PROCEDURE procedure-name
 WRAPPER_CLASS(MpSubprogramStmt, Name);
 
 // R1540 end-mp-subprogram-stmt -> END [PROCEDURE [procedure-name]]
 WRAPPER_CLASS(EndMpSubprogramStmt, std::optional<Name>);
 
 // R1538 separate-module-subprogram ->
 //         mp-subprogram-stmt [specification-part] [execution-part]
 //         [internal-subprogram-part] end-mp-subprogram-stmt
 struct SeparateModuleSubprogram {
   TUPLE_CLASS_BOILERPLATE(SeparateModuleSubprogram);
   std::tuple<Statement<MpSubprogramStmt>, SpecificationPart, ExecutionPart,
       std::optional<InternalSubprogramPart>, Statement<EndMpSubprogramStmt>>
       t;
 };
 
 // R1541 entry-stmt -> ENTRY entry-name [( [dummy-arg-list] ) [suffix]]
 struct EntryStmt {
   TUPLE_CLASS_BOILERPLATE(EntryStmt);
   std::tuple<Name, std::list<DummyArg>, std::optional<Suffix>> t;
 };
 
 // R1542 return-stmt -> RETURN [scalar-int-expr]
 WRAPPER_CLASS(ReturnStmt, std::optional<ScalarIntExpr>);
 
 // R1544 stmt-function-stmt ->
 //         function-name ( [dummy-arg-name-list] ) = scalar-expr
 struct StmtFunctionStmt {
   TUPLE_CLASS_BOILERPLATE(StmtFunctionStmt);
   std::tuple<Name, std::list<Name>, Scalar<Expr>> t;
   Statement<ActionStmt> ConvertToAssignment();
 };
 
 // Compiler directives
 // !DIR$ IGNORE_TKR [ [(tkr...)] name ]...
 // !DIR$ name...
 struct CompilerDirective {
   UNION_CLASS_BOILERPLATE(CompilerDirective);
   struct IgnoreTKR {
     TUPLE_CLASS_BOILERPLATE(IgnoreTKR);
     std::tuple<std::list<const char *>, Name> t;
   };
   struct NameValue {
     TUPLE_CLASS_BOILERPLATE(NameValue);
     std::tuple<Name, std::optional<std::uint64_t>> t;
   };
   CharBlock source;
   std::variant<std::list<IgnoreTKR>, std::list<NameValue>> u;
 };
 
 // Legacy extensions
 struct BasedPointer {
   TUPLE_CLASS_BOILERPLATE(BasedPointer);
   std::tuple<ObjectName, ObjectName, std::optional<ArraySpec>> t;
 };
 WRAPPER_CLASS(BasedPointerStmt, std::list<BasedPointer>);
 
 struct Union;
 struct StructureDef;
 
 struct StructureField {
   UNION_CLASS_BOILERPLATE(StructureField);
   std::variant<Statement<DataComponentDefStmt>,
       common::Indirection<StructureDef>, common::Indirection<Union>>
       u;
 };
 
 struct Map {
   EMPTY_CLASS(MapStmt);
   EMPTY_CLASS(EndMapStmt);
   TUPLE_CLASS_BOILERPLATE(Map);
   std::tuple<Statement<MapStmt>, std::list<StructureField>,
       Statement<EndMapStmt>>
       t;
 };
 
 struct Union {
   EMPTY_CLASS(UnionStmt);
   EMPTY_CLASS(EndUnionStmt);
   TUPLE_CLASS_BOILERPLATE(Union);
   std::tuple<Statement<UnionStmt>, std::list<Map>, Statement<EndUnionStmt>> t;
 };
 
 struct StructureStmt {
   TUPLE_CLASS_BOILERPLATE(StructureStmt);
   std::tuple<Name, bool /*slashes*/, std::list<EntityDecl>> t;
 };
 
 struct StructureDef {
   EMPTY_CLASS(EndStructureStmt);
   TUPLE_CLASS_BOILERPLATE(StructureDef);
   std::tuple<Statement<StructureStmt>, std::list<StructureField>,
       Statement<EndStructureStmt>>
       t;
 };
 
 // Old style PARAMETER statement without parentheses.
 // Types are determined entirely from the right-hand sides, not the names.
 WRAPPER_CLASS(OldParameterStmt, std::list<NamedConstantDef>);
 
 // Deprecations
 struct ArithmeticIfStmt {
   TUPLE_CLASS_BOILERPLATE(ArithmeticIfStmt);
   std::tuple<Expr, Label, Label, Label> t;
 };
 
 struct AssignStmt {
   TUPLE_CLASS_BOILERPLATE(AssignStmt);
   std::tuple<Label, Name> t;
 };
 
 struct AssignedGotoStmt {
   TUPLE_CLASS_BOILERPLATE(AssignedGotoStmt);
   std::tuple<Name, std::list<Label>> t;
 };
 
 WRAPPER_CLASS(PauseStmt, std::optional<StopCode>);
 
 // Parse tree nodes for OpenMP 4.5 directives and clauses
 
 // 2.5 proc-bind-clause -> PROC_BIND (MASTER | CLOSE | SPREAD)
 struct OmpProcBindClause {
   ENUM_CLASS(Type, Close, Master, Spread)
   WRAPPER_CLASS_BOILERPLATE(OmpProcBindClause, Type);
 };
 
 // 2.15.3.1 default-clause -> DEFAULT (PRIVATE | FIRSTPRIVATE | SHARED | NONE)
 struct OmpDefaultClause {
   ENUM_CLASS(Type, Private, Firstprivate, Shared, None)
   WRAPPER_CLASS_BOILERPLATE(OmpDefaultClause, Type);
 };
 
 // 2.1 Directives or clauses may accept a list or extended-list.
 //     A list item is a variable, array section or common block name (enclosed
 //     in slashes). An extended list item is a list item or a procedure Name.
 // variable-name | / common-block / | array-sections
 struct OmpObject {
   UNION_CLASS_BOILERPLATE(OmpObject);
   std::variant<Designator, /*common block*/ Name> u;
 };
 
 WRAPPER_CLASS(OmpObjectList, std::list<OmpObject>);
 
 // 2.15.5.1 map-type -> TO | FROM | TOFROM | ALLOC | RELEASE | DELETE
 struct OmpMapType {
   TUPLE_CLASS_BOILERPLATE(OmpMapType);
   EMPTY_CLASS(Always);
   ENUM_CLASS(Type, To, From, Tofrom, Alloc, Release, Delete)
   std::tuple<std::optional<Always>, Type> t;
 };
 
 // 2.15.5.1 map -> MAP ([ [ALWAYS[,]] map-type : ] variable-name-list)
 struct OmpMapClause {
   TUPLE_CLASS_BOILERPLATE(OmpMapClause);
   std::tuple<std::optional<OmpMapType>, OmpObjectList> t;
 };
 
 // 2.15.5.2 defaultmap -> DEFAULTMAP (implicit-behavior[:variable-category])
 struct OmpDefaultmapClause {
   TUPLE_CLASS_BOILERPLATE(OmpDefaultmapClause);
   ENUM_CLASS(ImplicitBehavior, Tofrom)
   ENUM_CLASS(VariableCategory, Scalar)
   std::tuple<ImplicitBehavior, std::optional<VariableCategory>> t;
 };
 
 // 2.7.1 sched-modifier -> MONOTONIC | NONMONOTONIC | SIMD
 struct OmpScheduleModifierType {
   ENUM_CLASS(ModType, Monotonic, Nonmonotonic, Simd)
   WRAPPER_CLASS_BOILERPLATE(OmpScheduleModifierType, ModType);
 };
 
 struct OmpScheduleModifier {
   TUPLE_CLASS_BOILERPLATE(OmpScheduleModifier);
   WRAPPER_CLASS(Modifier1, OmpScheduleModifierType);
   WRAPPER_CLASS(Modifier2, OmpScheduleModifierType);
   std::tuple<Modifier1, std::optional<Modifier2>> t;
 };
 
 // 2.7.1 schedule-clause -> SCHEDULE ([sched-modifier1] [, sched-modifier2]:]
 //                                    kind[, chunk_size])
 struct OmpScheduleClause {
   TUPLE_CLASS_BOILERPLATE(OmpScheduleClause);
   ENUM_CLASS(ScheduleType, Static, Dynamic, Guided, Auto, Runtime)
   std::tuple<std::optional<OmpScheduleModifier>, ScheduleType,
       std::optional<ScalarIntExpr>>
       t;
 };
 
 // 2.12 if-clause -> IF ([ directive-name-modifier :] scalar-logical-expr)
 struct OmpIfClause {
   TUPLE_CLASS_BOILERPLATE(OmpIfClause);
   ENUM_CLASS(DirectiveNameModifier, Parallel, Target, TargetEnterData,
       TargetExitData, TargetData, TargetUpdate, Taskloop, Task)
   std::tuple<std::optional<DirectiveNameModifier>, ScalarLogicalExpr> t;
 };
 
 // 2.8.1 aligned-clause -> ALIGNED (variable-name-list[ : scalar-constant])
 struct OmpAlignedClause {
   TUPLE_CLASS_BOILERPLATE(OmpAlignedClause);
   std::tuple<std::list<Name>, std::optional<ScalarIntConstantExpr>> t;
 };
 
 // 2.15.3.7 linear-modifier -> REF | VAL | UVAL
 struct OmpLinearModifier {
   ENUM_CLASS(Type, Ref, Val, Uval)
   WRAPPER_CLASS_BOILERPLATE(OmpLinearModifier, Type);
 };
 
 // 2.15.3.7 linear-clause -> LINEAR (linear-list[ : linear-step])
 //          linear-list -> list | linear-modifier(list)
 struct OmpLinearClause {
   UNION_CLASS_BOILERPLATE(OmpLinearClause);
   struct WithModifier {
     BOILERPLATE(WithModifier);
     WithModifier(OmpLinearModifier &&m, std::list<Name> &&n,
         std::optional<ScalarIntConstantExpr> &&s)
         : modifier(std::move(m)), names(std::move(n)), step(std::move(s)) {}
     OmpLinearModifier modifier;
     std::list<Name> names;
     std::optional<ScalarIntConstantExpr> step;
   };
   struct WithoutModifier {
     BOILERPLATE(WithoutModifier);
     WithoutModifier(
         std::list<Name> &&n, std::optional<ScalarIntConstantExpr> &&s)
         : names(std::move(n)), step(std::move(s)) {}
     std::list<Name> names;
     std::optional<ScalarIntConstantExpr> step;
   };
   std::variant<WithModifier, WithoutModifier> u;
 };
 
 // 2.15.3.6 reduction-identifier -> + | - | * | .AND. | .OR. | .EQV. | .NEQV. |
 //                         MAX | MIN | IAND | IOR | IEOR
 struct OmpReductionOperator {
   UNION_CLASS_BOILERPLATE(OmpReductionOperator);
   std::variant<DefinedOperator, ProcedureDesignator> u;
 };
 
 // 2.15.3.6 reduction-clause -> REDUCTION (reduction-identifier:
 //                                         variable-name-list)
 struct OmpReductionClause {
   TUPLE_CLASS_BOILERPLATE(OmpReductionClause);
   std::tuple<OmpReductionOperator, std::list<Designator>> t;
 };
 
 // OMP 5.0 2.11.4 allocate-clause -> ALLOCATE ([allocator:] variable-name-list)
 struct OmpAllocateClause {
   TUPLE_CLASS_BOILERPLATE(OmpAllocateClause);
   WRAPPER_CLASS(Allocator, ScalarIntExpr);
   std::tuple<std::optional<Allocator>, OmpObjectList> t;
 };
 
 // 2.13.9 depend-vec-length -> +/- non-negative-constant
 struct OmpDependSinkVecLength {
   TUPLE_CLASS_BOILERPLATE(OmpDependSinkVecLength);
   std::tuple<DefinedOperator, ScalarIntConstantExpr> t;
 };
 
 // 2.13.9 depend-vec -> iterator [+/- depend-vec-length],...,iterator[...]
 struct OmpDependSinkVec {
   TUPLE_CLASS_BOILERPLATE(OmpDependSinkVec);
   std::tuple<Name, std::optional<OmpDependSinkVecLength>> t;
 };
 
 // 2.13.9 depend-type -> IN | OUT | INOUT | SOURCE | SINK
 struct OmpDependenceType {
   ENUM_CLASS(Type, In, Out, Inout, Source, Sink)
   WRAPPER_CLASS_BOILERPLATE(OmpDependenceType, Type);
 };
 
 // 2.13.9 depend-clause -> DEPEND (((IN | OUT | INOUT) : variable-name-list) |
 //                                 SOURCE | SINK : depend-vec)
 struct OmpDependClause {
   UNION_CLASS_BOILERPLATE(OmpDependClause);
   EMPTY_CLASS(Source);
   WRAPPER_CLASS(Sink, std::list<OmpDependSinkVec>);
   struct InOut {
     TUPLE_CLASS_BOILERPLATE(InOut);
     std::tuple<OmpDependenceType, std::list<Designator>> t;
   };
   std::variant<Source, Sink, InOut> u;
 };
 
 // 2.7.1 nowait-clause -> NOWAIT
 EMPTY_CLASS(OmpNowait);
 
 // OpenMP Clauses
 struct OmpClause {
   UNION_CLASS_BOILERPLATE(OmpClause);
   EMPTY_CLASS(Inbranch);
   EMPTY_CLASS(Mergeable);
   EMPTY_CLASS(Nogroup);
   EMPTY_CLASS(Notinbranch);
   EMPTY_CLASS(Simd);
   EMPTY_CLASS(Threads);
   EMPTY_CLASS(Untied);
   WRAPPER_CLASS(Collapse, ScalarIntConstantExpr);
   WRAPPER_CLASS(Copyin, OmpObjectList);
   WRAPPER_CLASS(Copyprivate, OmpObjectList);
   WRAPPER_CLASS(Device, ScalarIntExpr);
   WRAPPER_CLASS(DistSchedule, std::optional<ScalarIntExpr>);
   WRAPPER_CLASS(Final, ScalarLogicalExpr);
   WRAPPER_CLASS(Firstprivate, OmpObjectList);
   WRAPPER_CLASS(From, OmpObjectList);
   WRAPPER_CLASS(Grainsize, ScalarIntExpr);
   WRAPPER_CLASS(IsDevicePtr, std::list<Name>);
   WRAPPER_CLASS(Lastprivate, OmpObjectList);
   WRAPPER_CLASS(Link, OmpObjectList);
   WRAPPER_CLASS(NumTasks, ScalarIntExpr);
   WRAPPER_CLASS(NumTeams, ScalarIntExpr);
   WRAPPER_CLASS(NumThreads, ScalarIntExpr);
   WRAPPER_CLASS(Ordered, std::optional<ScalarIntConstantExpr>);
   WRAPPER_CLASS(Priority, ScalarIntExpr);
   WRAPPER_CLASS(Private, OmpObjectList);
   WRAPPER_CLASS(Safelen, ScalarIntConstantExpr);
   WRAPPER_CLASS(Shared, OmpObjectList);
   WRAPPER_CLASS(Simdlen, ScalarIntConstantExpr);
   WRAPPER_CLASS(ThreadLimit, ScalarIntExpr);
   WRAPPER_CLASS(To, OmpObjectList);
   WRAPPER_CLASS(Uniform, std::list<Name>);
   WRAPPER_CLASS(UseDevicePtr, std::list<Name>);
   CharBlock source;
   std::variant<Inbranch, Mergeable, Nogroup, Notinbranch, OmpNowait, Untied,
       Threads, Simd, Collapse, Copyin, Copyprivate, Device, DistSchedule, Final,
       Firstprivate, From, Grainsize, Lastprivate, NumTasks, NumTeams,
       NumThreads, Ordered, Priority, Private, Safelen, Shared, Simdlen,
       ThreadLimit, To, Link, Uniform, UseDevicePtr, IsDevicePtr,
       OmpAlignedClause, OmpAllocateClause, OmpDefaultClause,
       OmpDefaultmapClause, OmpDependClause, OmpIfClause, OmpLinearClause,
       OmpMapClause, OmpProcBindClause, OmpReductionClause, OmpScheduleClause>
       u;
 };
 
 struct OmpClauseList {
   WRAPPER_CLASS_BOILERPLATE(OmpClauseList, std::list<OmpClause>);
   CharBlock source;
 };
 
 // 2.7.2 SECTIONS
 // 2.11.2 PARALLEL SECTIONS
 struct OmpSectionsDirective {
   WRAPPER_CLASS_BOILERPLATE(OmpSectionsDirective, llvm::omp::Directive);
   CharBlock source;
 };
 
 struct OmpBeginSectionsDirective {
   TUPLE_CLASS_BOILERPLATE(OmpBeginSectionsDirective);
   std::tuple<OmpSectionsDirective, OmpClauseList> t;
   CharBlock source;
 };
 struct OmpEndSectionsDirective {
   TUPLE_CLASS_BOILERPLATE(OmpEndSectionsDirective);
   std::tuple<OmpSectionsDirective, OmpClauseList> t;
   CharBlock source;
 };
 
 // [!$omp section]
 //    structured-block
 // [!$omp section
 //    structured-block]
 // ...
 WRAPPER_CLASS(OmpSectionBlocks, std::list<Block>);
 
 struct OpenMPSectionsConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenMPSectionsConstruct);
   std::tuple<OmpBeginSectionsDirective, OmpSectionBlocks,
       OmpEndSectionsDirective>
       t;
 };
 
 // OpenMP directive beginning or ending a block
 struct OmpBlockDirective {
   WRAPPER_CLASS_BOILERPLATE(OmpBlockDirective, llvm::omp::Directive);
   CharBlock source;
 };
 
 // 2.10.6 declare-target -> DECLARE TARGET (extended-list) |
 //                          DECLARE TARGET [declare-target-clause[ [,]
 //                                          declare-target-clause]...]
 struct OmpDeclareTargetWithList {
   WRAPPER_CLASS_BOILERPLATE(OmpDeclareTargetWithList, OmpObjectList);
   CharBlock source;
 };
 
 struct OmpDeclareTargetWithClause {
   WRAPPER_CLASS_BOILERPLATE(OmpDeclareTargetWithClause, OmpClauseList);
   CharBlock source;
 };
 
 struct OmpDeclareTargetSpecifier {
   UNION_CLASS_BOILERPLATE(OmpDeclareTargetSpecifier);
   std::variant<OmpDeclareTargetWithList, OmpDeclareTargetWithClause> u;
 };
 
 struct OpenMPDeclareTargetConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenMPDeclareTargetConstruct);
   CharBlock source;
   std::tuple<Verbatim, OmpDeclareTargetSpecifier> t;
 };
 
 // 2.16 declare-reduction -> DECLARE REDUCTION (reduction-identifier : type-list
 //                                              : combiner) [initializer-clause]
 struct OmpReductionCombiner {
   UNION_CLASS_BOILERPLATE(OmpReductionCombiner);
   WRAPPER_CLASS(FunctionCombiner, Call);
   std::variant<AssignmentStmt, FunctionCombiner> u;
 };
 
 WRAPPER_CLASS(OmpReductionInitializerClause, Expr);
 
 struct OpenMPDeclareReductionConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenMPDeclareReductionConstruct);
   CharBlock source;
   std::tuple<Verbatim, OmpReductionOperator, std::list<DeclarationTypeSpec>,
       OmpReductionCombiner, std::optional<OmpReductionInitializerClause>>
       t;
 };
 
 // 2.8.2 declare-simd -> DECLARE SIMD [(proc-name)] [declare-simd-clause[ [,]
 //                                                   declare-simd-clause]...]
 struct OpenMPDeclareSimdConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenMPDeclareSimdConstruct);
   CharBlock source;
   std::tuple<Verbatim, std::optional<Name>, OmpClauseList> t;
 };
 
 // 2.15.2 threadprivate -> THREADPRIVATE (variable-name-list)
 struct OpenMPThreadprivate {
   TUPLE_CLASS_BOILERPLATE(OpenMPThreadprivate);
   CharBlock source;
   std::tuple<Verbatim, OmpObjectList> t;
 };
 
 struct OpenMPDeclarativeConstruct {
   UNION_CLASS_BOILERPLATE(OpenMPDeclarativeConstruct);
   CharBlock source;
   std::variant<OpenMPDeclareReductionConstruct, OpenMPDeclareSimdConstruct,
       OpenMPDeclareTargetConstruct, OpenMPThreadprivate>
       u;
 };
 
 // 2.13.2 CRITICAL [Name] <block> END CRITICAL [Name]
 struct OmpCriticalDirective {
   TUPLE_CLASS_BOILERPLATE(OmpCriticalDirective);
   WRAPPER_CLASS(Hint, ConstantExpr);
   CharBlock source;
   std::tuple<Verbatim, std::optional<Name>, std::optional<Hint>> t;
 };
 struct OmpEndCriticalDirective {
   TUPLE_CLASS_BOILERPLATE(OmpEndCriticalDirective);
   CharBlock source;
   std::tuple<Verbatim, std::optional<Name>> t;
 };
 struct OpenMPCriticalConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenMPCriticalConstruct);
   std::tuple<OmpCriticalDirective, Block, OmpEndCriticalDirective> t;
 };
 
 // 2.13.6 atomic -> ATOMIC [seq_cst[,]] atomic-clause [[,]seq_cst] |
 //                  ATOMIC [seq_cst]
 //        atomic-clause -> READ | WRITE | UPDATE | CAPTURE
 
 // END ATOMIC
 EMPTY_CLASS(OmpEndAtomic);
 
 // ATOMIC Memory related clause
 struct OmpMemoryClause {
   ENUM_CLASS(MemoryOrder, SeqCst)
   WRAPPER_CLASS_BOILERPLATE(OmpMemoryClause, MemoryOrder);
   CharBlock source;
 };
 
 WRAPPER_CLASS(OmpMemoryClauseList, std::list<OmpMemoryClause>);
 WRAPPER_CLASS(OmpMemoryClausePostList, std::list<OmpMemoryClause>);
 
 // ATOMIC READ
 struct OmpAtomicRead {
   TUPLE_CLASS_BOILERPLATE(OmpAtomicRead);
   std::tuple<OmpMemoryClauseList, Verbatim, OmpMemoryClausePostList,
       Statement<AssignmentStmt>, std::optional<OmpEndAtomic>>
       t;
 };
 
 // ATOMIC WRITE
 struct OmpAtomicWrite {
   TUPLE_CLASS_BOILERPLATE(OmpAtomicWrite);
   std::tuple<OmpMemoryClauseList, Verbatim, OmpMemoryClausePostList,
       Statement<AssignmentStmt>, std::optional<OmpEndAtomic>>
       t;
 };
 
 // ATOMIC UPDATE
 struct OmpAtomicUpdate {
   TUPLE_CLASS_BOILERPLATE(OmpAtomicUpdate);
   std::tuple<OmpMemoryClauseList, Verbatim, OmpMemoryClausePostList,
       Statement<AssignmentStmt>, std::optional<OmpEndAtomic>>
       t;
 };
 
 // ATOMIC CAPTURE
 struct OmpAtomicCapture {
   TUPLE_CLASS_BOILERPLATE(OmpAtomicCapture);
   WRAPPER_CLASS(Stmt1, Statement<AssignmentStmt>);
   WRAPPER_CLASS(Stmt2, Statement<AssignmentStmt>);
   std::tuple<OmpMemoryClauseList, Verbatim, OmpMemoryClausePostList, Stmt1,
       Stmt2, OmpEndAtomic>
       t;
 };
 
 // ATOMIC
 struct OmpAtomic {
   TUPLE_CLASS_BOILERPLATE(OmpAtomic);
   std::tuple<Verbatim, OmpMemoryClauseList, Statement<AssignmentStmt>,
       std::optional<OmpEndAtomic>>
       t;
 };
 
 struct OpenMPAtomicConstruct {
   UNION_CLASS_BOILERPLATE(OpenMPAtomicConstruct);
   std::variant<OmpAtomicRead, OmpAtomicWrite, OmpAtomicCapture, OmpAtomicUpdate,
       OmpAtomic>
       u;
 };
 
 // OpenMP directives that associate with loop(s)
 struct OmpLoopDirective {
   WRAPPER_CLASS_BOILERPLATE(OmpLoopDirective, llvm::omp::Directive);
   CharBlock source;
 };
 
 // 2.14.1 construct-type-clause -> PARALLEL | SECTIONS | DO | TASKGROUP
 struct OmpCancelType {
   ENUM_CLASS(Type, Parallel, Sections, Do, Taskgroup)
   WRAPPER_CLASS_BOILERPLATE(OmpCancelType, Type);
   CharBlock source;
 };
 
 // 2.14.2 cancellation-point -> CANCELLATION POINT construct-type-clause
 struct OpenMPCancellationPointConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenMPCancellationPointConstruct);
   CharBlock source;
   std::tuple<Verbatim, OmpCancelType> t;
 };
 
 // 2.14.1 cancel -> CANCEL construct-type-clause [ [,] if-clause]
 struct OpenMPCancelConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenMPCancelConstruct);
   WRAPPER_CLASS(If, ScalarLogicalExpr);
   CharBlock source;
   std::tuple<Verbatim, OmpCancelType, std::optional<If>> t;
 };
 
 // 2.17.8 Flush Construct [OpenMP 5.0]
 // memory-order-clause -> acq_rel
 //                        release
 //                        acquire
 struct OmpFlushMemoryClause {
   ENUM_CLASS(FlushMemoryOrder, AcqRel, Release, Acquire)
   WRAPPER_CLASS_BOILERPLATE(OmpFlushMemoryClause, FlushMemoryOrder);
   CharBlock source;
 };
 
 // 2.17.8 flush -> FLUSH [memory-order-clause] [(variable-name-list)]
 struct OpenMPFlushConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenMPFlushConstruct);
   CharBlock source;
   std::tuple<Verbatim, std::optional<OmpFlushMemoryClause>,
       std::optional<OmpObjectList>>
       t;
 };
 
 struct OmpSimpleStandaloneDirective {
   WRAPPER_CLASS_BOILERPLATE(OmpSimpleStandaloneDirective, llvm::omp::Directive);
   CharBlock source;
 };
 
 struct OpenMPSimpleStandaloneConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenMPSimpleStandaloneConstruct);
   CharBlock source;
   std::tuple<OmpSimpleStandaloneDirective, OmpClauseList> t;
 };
 
 struct OpenMPStandaloneConstruct {
   UNION_CLASS_BOILERPLATE(OpenMPStandaloneConstruct);
   CharBlock source;
   std::variant<OpenMPSimpleStandaloneConstruct, OpenMPFlushConstruct,
       OpenMPCancelConstruct, OpenMPCancellationPointConstruct>
       u;
 };
 
 struct OmpBeginLoopDirective {
   TUPLE_CLASS_BOILERPLATE(OmpBeginLoopDirective);
   std::tuple<OmpLoopDirective, OmpClauseList> t;
   CharBlock source;
 };
 
 struct OmpEndLoopDirective {
   TUPLE_CLASS_BOILERPLATE(OmpEndLoopDirective);
   std::tuple<OmpLoopDirective, OmpClauseList> t;
   CharBlock source;
 };
 
 struct OmpBeginBlockDirective {
   TUPLE_CLASS_BOILERPLATE(OmpBeginBlockDirective);
   std::tuple<OmpBlockDirective, OmpClauseList> t;
   CharBlock source;
 };
 
 struct OmpEndBlockDirective {
   TUPLE_CLASS_BOILERPLATE(OmpEndBlockDirective);
   std::tuple<OmpBlockDirective, OmpClauseList> t;
   CharBlock source;
 };
 
 struct OpenMPBlockConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenMPBlockConstruct);
   std::tuple<OmpBeginBlockDirective, Block, OmpEndBlockDirective> t;
 };
 
 // OpenMP directives enclosing do loop
 struct OpenMPLoopConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenMPLoopConstruct);
   OpenMPLoopConstruct(OmpBeginLoopDirective &&a)
       : t({std::move(a), std::nullopt, std::nullopt}) {}
   std::tuple<OmpBeginLoopDirective, std::optional<DoConstruct>,
       std::optional<OmpEndLoopDirective>>
       t;
 };
 
 struct OpenMPConstruct {
   UNION_CLASS_BOILERPLATE(OpenMPConstruct);
   std::variant<OpenMPStandaloneConstruct, OpenMPSectionsConstruct,
       OpenMPLoopConstruct, OpenMPBlockConstruct, OpenMPAtomicConstruct,
       OpenMPCriticalConstruct>
       u;
 };
 
 // Parse tree nodes for OpenACC 3.0 directives and clauses
 
 struct AccObject {
   UNION_CLASS_BOILERPLATE(AccObject);
   std::variant<Designator, /*common block*/ Name> u;
 };
 
 WRAPPER_CLASS(AccObjectList, std::list<AccObject>);
 
 // OpenACC directive beginning or ending a block
 struct AccBlockDirective {
   WRAPPER_CLASS_BOILERPLATE(AccBlockDirective, llvm::acc::Directive);
   CharBlock source;
 };
 
 struct AccLoopDirective {
   WRAPPER_CLASS_BOILERPLATE(AccLoopDirective, llvm::acc::Directive);
   CharBlock source;
 };
 
 struct AccStandaloneDirective {
   WRAPPER_CLASS_BOILERPLATE(AccStandaloneDirective, llvm::acc::Directive);
   CharBlock source;
 };
 
 // 2.11 Combined constructs
 struct AccCombinedDirective {
   WRAPPER_CLASS_BOILERPLATE(AccCombinedDirective, llvm::acc::Directive);
   CharBlock source;
 };
 
 struct AccDeclarativeDirective {
   WRAPPER_CLASS_BOILERPLATE(AccDeclarativeDirective, llvm::acc::Directive);
   CharBlock source;
 };
 
 // OpenACC Clauses
 struct AccDefaultClause {
   ENUM_CLASS(Arg, None, Present)
   WRAPPER_CLASS_BOILERPLATE(AccDefaultClause, Arg);
   CharBlock source;
 };
 
 struct AccDataModifier {
   ENUM_CLASS(Modifier, ReadOnly, Zero)
   WRAPPER_CLASS_BOILERPLATE(AccDataModifier, Modifier);
   CharBlock source;
 };
 
 struct AccObjectListWithModifier {
   TUPLE_CLASS_BOILERPLATE(AccObjectListWithModifier);
   std::tuple<std::optional<AccDataModifier>, AccObjectList> t;
 };
 
 // 2.5.13: + | * | max | min | iand | ior | ieor | .and. | .or. | .eqv. | .neqv.
 struct AccReductionOperator {
   UNION_CLASS_BOILERPLATE(AccReductionOperator);
   std::variant<DefinedOperator, ProcedureDesignator> u;
 };
 
 struct AccObjectListWithReduction {
   TUPLE_CLASS_BOILERPLATE(AccObjectListWithReduction);
   std::tuple<AccReductionOperator, AccObjectList> t;
 };
 
 struct AccWaitArgument {
   TUPLE_CLASS_BOILERPLATE(AccWaitArgument);
   std::tuple<std::optional<ScalarIntExpr>, std::list<ScalarIntExpr>> t;
 };
 
 struct AccSizeExpr {
   TUPLE_CLASS_BOILERPLATE(AccSizeExpr);
   CharBlock source;
   std::tuple<std::optional<ScalarIntExpr>> t; // if null then *
 };
 
 struct AccSizeExprList {
   WRAPPER_CLASS_BOILERPLATE(AccSizeExprList, std::list<AccSizeExpr>);
 };
 
 struct AccGangArgument {
   TUPLE_CLASS_BOILERPLATE(AccGangArgument);
   std::tuple<std::optional<ScalarIntExpr>, std::optional<AccSizeExpr>> t;
 };
 
 struct AccClause {
   UNION_CLASS_BOILERPLATE(AccClause);
 
   EMPTY_CLASS(Auto);
   WRAPPER_CLASS(Async, std::optional<ScalarIntExpr>);
   WRAPPER_CLASS(Attach, AccObjectList);
   WRAPPER_CLASS(Bind, Name);
   EMPTY_CLASS(Capture);
   WRAPPER_CLASS(Collapse, ScalarIntConstantExpr);
   WRAPPER_CLASS(Copy, AccObjectList);
   WRAPPER_CLASS(Copyin, AccObjectListWithModifier);
   WRAPPER_CLASS(Copyout, AccObjectListWithModifier);
   WRAPPER_CLASS(Create, AccObjectListWithModifier);
   WRAPPER_CLASS(Default, AccDefaultClause);
   WRAPPER_CLASS(DefaultAsync, ScalarIntExpr);
   WRAPPER_CLASS(Delete, AccObjectList);
   WRAPPER_CLASS(Detach, AccObjectList);
   WRAPPER_CLASS(Device, AccObjectList);
   WRAPPER_CLASS(DeviceNum, ScalarIntConstantExpr);
   WRAPPER_CLASS(DevicePtr, AccObjectList);
   WRAPPER_CLASS(DeviceResident, AccObjectList);
   WRAPPER_CLASS(DeviceType, std::optional<std::list<Name>>);
   EMPTY_CLASS(Finalize);
   WRAPPER_CLASS(FirstPrivate, AccObjectList);
   WRAPPER_CLASS(Gang, std::optional<AccGangArgument>);
   WRAPPER_CLASS(Host, AccObjectList);
   WRAPPER_CLASS(If, ScalarLogicalExpr);
   EMPTY_CLASS(IfPresent);
   EMPTY_CLASS(Independent);
   WRAPPER_CLASS(Link, AccObjectList);
   WRAPPER_CLASS(NoCreate, AccObjectList);
   EMPTY_CLASS(NoHost);
   WRAPPER_CLASS(NumGangs, ScalarIntExpr);
   WRAPPER_CLASS(NumWorkers, ScalarIntExpr);
   WRAPPER_CLASS(Present, AccObjectList);
   WRAPPER_CLASS(Private, AccObjectList);
   WRAPPER_CLASS(Tile, AccSizeExprList);
   WRAPPER_CLASS(UseDevice, AccObjectList);
   EMPTY_CLASS(Read);
   WRAPPER_CLASS(Reduction, AccObjectListWithReduction);
   WRAPPER_CLASS(Self, std::optional<ScalarLogicalExpr>);
   EMPTY_CLASS(Seq);
   WRAPPER_CLASS(Vector, std::optional<ScalarIntExpr>);
   WRAPPER_CLASS(VectorLength, ScalarIntExpr);
   WRAPPER_CLASS(Wait, std::optional<AccWaitArgument>);
   WRAPPER_CLASS(Worker, std::optional<ScalarIntExpr>);
   EMPTY_CLASS(Write);
   EMPTY_CLASS(Unknown);
 
   CharBlock source;
 
   std::variant<Auto, Async, Attach, Bind, Capture, Collapse, Copy, Copyin,
       Copyout, Create, Default, DefaultAsync, Delete, Detach, Device, DeviceNum,
       DevicePtr, DeviceResident, DeviceType, Finalize, FirstPrivate, Gang, Host,
       If, IfPresent, Independent, Link, NoCreate, NoHost, NumGangs, NumWorkers,
       Present, Private, Tile, UseDevice, Read, Reduction, Self, Seq, Vector,
       VectorLength, Wait, Worker, Write, Unknown>
       u;
 };
 
 struct AccClauseList {
   WRAPPER_CLASS_BOILERPLATE(AccClauseList, std::list<AccClause>);
   CharBlock source;
 };
 
 struct OpenACCRoutineConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenACCRoutineConstruct);
   CharBlock source;
   std::tuple<Verbatim, std::optional<Name>, AccClauseList> t;
 };
 
 struct OpenACCCacheConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenACCCacheConstruct);
   CharBlock source;
   std::tuple<Verbatim, AccObjectListWithModifier> t;
 };
 
 struct OpenACCWaitConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenACCWaitConstruct);
   CharBlock source;
   std::tuple<Verbatim, std::optional<AccWaitArgument>, AccClauseList> t;
 };
 
 struct AccBeginLoopDirective {
   TUPLE_CLASS_BOILERPLATE(AccBeginLoopDirective);
   std::tuple<AccLoopDirective, AccClauseList> t;
   CharBlock source;
 };
 
 struct AccBeginBlockDirective {
   TUPLE_CLASS_BOILERPLATE(AccBeginBlockDirective);
   CharBlock source;
   std::tuple<AccBlockDirective, AccClauseList> t;
 };
 
 struct AccEndBlockDirective {
   CharBlock source;
   WRAPPER_CLASS_BOILERPLATE(AccEndBlockDirective, AccBlockDirective);
 };
 
 // ACC END ATOMIC
 EMPTY_CLASS(AccEndAtomic);
 
 // ACC ATOMIC READ
 struct AccAtomicRead {
   TUPLE_CLASS_BOILERPLATE(AccAtomicRead);
   std::tuple<Verbatim, Statement<AssignmentStmt>, std::optional<AccEndAtomic>>
       t;
 };
 
 // ACC ATOMIC WRITE
 struct AccAtomicWrite {
   TUPLE_CLASS_BOILERPLATE(AccAtomicWrite);
   std::tuple<Verbatim, Statement<AssignmentStmt>, std::optional<AccEndAtomic>>
       t;
 };
 
 // ACC ATOMIC UPDATE
 struct AccAtomicUpdate {
   TUPLE_CLASS_BOILERPLATE(AccAtomicUpdate);
   std::tuple<std::optional<Verbatim>, Statement<AssignmentStmt>,
       std::optional<AccEndAtomic>>
       t;
 };
 
 // ACC ATOMIC CAPTURE
 struct AccAtomicCapture {
   TUPLE_CLASS_BOILERPLATE(AccAtomicCapture);
   WRAPPER_CLASS(Stmt1, Statement<AssignmentStmt>);
   WRAPPER_CLASS(Stmt2, Statement<AssignmentStmt>);
   std::tuple<Verbatim, Stmt1, Stmt2, AccEndAtomic> t;
 };
 
 struct OpenACCAtomicConstruct {
   UNION_CLASS_BOILERPLATE(OpenACCAtomicConstruct);
   std::variant<AccAtomicRead, AccAtomicWrite, AccAtomicCapture, AccAtomicUpdate>
       u;
 };
 
 struct OpenACCBlockConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenACCBlockConstruct);
   std::tuple<AccBeginBlockDirective, Block, AccEndBlockDirective> t;
 };
 
 struct OpenACCStandaloneDeclarativeConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenACCStandaloneDeclarativeConstruct);
   CharBlock source;
   std::tuple<AccDeclarativeDirective, AccClauseList> t;
 };
 
 struct AccBeginCombinedDirective {
   TUPLE_CLASS_BOILERPLATE(AccBeginCombinedDirective);
   std::tuple<AccCombinedDirective, AccClauseList> t;
 };
 
 struct AccEndCombinedDirective {
   WRAPPER_CLASS_BOILERPLATE(AccEndCombinedDirective, AccCombinedDirective);
   CharBlock source;
 };
 
 struct OpenACCCombinedConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenACCCombinedConstruct);
   CharBlock source;
   std::tuple<AccBeginCombinedDirective, Block,
       std::optional<AccEndCombinedDirective>>
       t;
 };
 
 struct OpenACCDeclarativeConstruct {
   UNION_CLASS_BOILERPLATE(OpenACCDeclarativeConstruct);
   CharBlock source;
   std::variant<OpenACCStandaloneDeclarativeConstruct> u;
 };
 
 // OpenACC directives enclosing do loop
 struct OpenACCLoopConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenACCLoopConstruct);
   OpenACCLoopConstruct(AccBeginLoopDirective &&a)
       : t({std::move(a), std::nullopt}) {}
   std::tuple<AccBeginLoopDirective, std::optional<DoConstruct>> t;
 };
 
 struct OpenACCStandaloneConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenACCStandaloneConstruct);
   CharBlock source;
   std::tuple<AccStandaloneDirective, AccClauseList> t;
 };
 
 struct OpenACCConstruct {
   UNION_CLASS_BOILERPLATE(OpenACCConstruct);
   std::variant<OpenACCBlockConstruct, OpenACCCombinedConstruct,
       OpenACCLoopConstruct, OpenACCStandaloneConstruct, OpenACCRoutineConstruct,
       OpenACCCacheConstruct, OpenACCWaitConstruct, OpenACCAtomicConstruct>
       u;
 };
 
 } // namespace Fortran::parser
 #endif // FORTRAN_PARSER_PARSE_TREE_H_
diff --git a/flang/include/flang/Semantics/expression.h b/flang/include/flang/Semantics/expression.h
index 4148a0d605d8..7daeeba507f6 100644
--- a/flang/include/flang/Semantics/expression.h
+++ b/flang/include/flang/Semantics/expression.h
@@ -1,480 +1,480 @@
 //===-- 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/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"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Parser/tools.h"
 #include <map>
 #include <optional>
 #include <type_traits>
 #include <variant>
 
 using namespace Fortran::parser::literals;
 
 namespace Fortran::parser {
 struct SourceLocationFindingVisitor {
   template <typename A> bool Pre(const A &x) {
     if constexpr (HasSource<A>::value) {
       source.ExtendToCover(x.source);
       return false;
     } else {
       return true;
     }
   }
   template <typename A> void Post(const A &) {}
   void Post(const CharBlock &at) { source.ExtendToCover(at); }
 
   CharBlock source;
 };
 
 template <typename A> CharBlock FindSourceLocation(const A &x) {
   SourceLocationFindingVisitor visitor;
   Walk(x, visitor);
   return visitor.source;
 }
 } // namespace Fortran::parser
 
 using namespace Fortran::parser::literals;
 
 // The expression semantic analysis code has its implementation in
 // namespace Fortran::evaluate, but the exposed API to it is in the
 // namespace Fortran::semantics (below).
 //
 // The ExpressionAnalyzer wraps a SemanticsContext reference
 // and implements constraint checking on expressions using the
 // parse tree node wrappers that mirror the grammar annotations used
 // in the Fortran standard (i.e., scalar-, constant-, &c.).
 
 namespace Fortran::evaluate {
 
 class IntrinsicProcTable;
 
 struct SetExprHelper {
   explicit SetExprHelper(GenericExprWrapper &&expr) : expr_{std::move(expr)} {}
   void Set(parser::TypedExpr &x) {
     x.Reset(new GenericExprWrapper{std::move(expr_)},
         evaluate::GenericExprWrapper::Deleter);
   }
   void Set(const parser::Expr &x) { Set(x.typedExpr); }
   void Set(const parser::Variable &x) { Set(x.typedExpr); }
   void Set(const parser::DataStmtConstant &x) { Set(x.typedExpr); }
   template <typename T> void Set(const common::Indirection<T> &x) {
     Set(x.value());
   }
   template <typename T> void Set(const T &x) {
     if constexpr (ConstraintTrait<T>) {
       Set(x.thing);
     } else if constexpr (WrapperTrait<T>) {
       Set(x.v);
     }
   }
 
   GenericExprWrapper expr_;
 };
 
 template <typename T> void ResetExpr(const T &x) {
   SetExprHelper{GenericExprWrapper{/* error indicator */}}.Set(x);
 }
 
 template <typename T> void SetExpr(const T &x, Expr<SomeType> &&expr) {
   SetExprHelper{GenericExprWrapper{std::move(expr)}}.Set(x);
 }
 
 class ExpressionAnalyzer {
 public:
   using MaybeExpr = std::optional<Expr<SomeType>>;
 
   explicit ExpressionAnalyzer(semantics::SemanticsContext &sc) : context_{sc} {}
   ExpressionAnalyzer(semantics::SemanticsContext &sc, FoldingContext &fc)
       : context_{sc}, foldingContext_{fc} {}
   ExpressionAnalyzer(ExpressionAnalyzer &) = default;
 
   semantics::SemanticsContext &context() const { return context_; }
 
   FoldingContext &GetFoldingContext() const { return foldingContext_; }
 
   parser::ContextualMessages &GetContextualMessages() {
     return foldingContext_.messages();
   }
 
-  template <typename... A> parser::Message *Say(A &&... args) {
+  template <typename... A> parser::Message *Say(A &&...args) {
     return GetContextualMessages().Say(std::forward<A>(args)...);
   }
 
   template <typename T, typename... A>
-  parser::Message *SayAt(const T &parsed, A &&... args) {
+  parser::Message *SayAt(const T &parsed, A &&...args) {
     return Say(parser::FindSourceLocation(parsed), std::forward<A>(args)...);
   }
 
   int GetDefaultKind(common::TypeCategory);
   DynamicType GetDefaultKindOfType(common::TypeCategory);
 
   // Return false and emit error if these checks fail:
   bool CheckIntrinsicKind(TypeCategory, std::int64_t kind);
   bool CheckIntrinsicSize(TypeCategory, std::int64_t size);
 
   // Manage a set of active implied DO loops.
   bool AddImpliedDo(parser::CharBlock, int kind);
   void RemoveImpliedDo(parser::CharBlock);
 
   // When the argument is the name of an active implied DO index, returns
   // its INTEGER kind type parameter.
   std::optional<int> IsImpliedDo(parser::CharBlock) const;
 
   Expr<SubscriptInteger> AnalyzeKindSelector(common::TypeCategory category,
       const std::optional<parser::KindSelector> &);
 
   MaybeExpr Analyze(const parser::Expr &);
   MaybeExpr Analyze(const parser::Variable &);
   MaybeExpr Analyze(const parser::Designator &);
   MaybeExpr Analyze(const parser::DataStmtValue &);
 
   template <typename A> MaybeExpr Analyze(const common::Indirection<A> &x) {
     return Analyze(x.value());
   }
   template <typename A> MaybeExpr Analyze(const std::optional<A> &x) {
     if (x) {
       return Analyze(*x);
     } else {
       return std::nullopt;
     }
   }
 
   // Implement constraint-checking wrappers from the Fortran grammar.
   template <typename A> MaybeExpr Analyze(const parser::Scalar<A> &x) {
     auto result{Analyze(x.thing)};
     if (result) {
       if (int rank{result->Rank()}; rank != 0) {
         SayAt(x, "Must be a scalar value, but is a rank-%d array"_err_en_US,
             rank);
         ResetExpr(x);
         return std::nullopt;
       }
     }
     return result;
   }
   template <typename A> MaybeExpr Analyze(const parser::Constant<A> &x) {
     auto restorer{
         GetFoldingContext().messages().SetLocation(FindSourceLocation(x))};
     auto result{Analyze(x.thing)};
     if (result) {
       *result = Fold(std::move(*result));
       if (!IsConstantExpr(*result)) { //  C886, C887, C713
         SayAt(x, "Must be a constant value"_err_en_US);
         ResetExpr(x);
         return std::nullopt;
       } else {
         // Save folded expression for later use
         SetExpr(x, common::Clone(*result));
       }
     }
     return result;
   }
   template <typename A> MaybeExpr Analyze(const parser::Integer<A> &x) {
     auto result{Analyze(x.thing)};
     if (!EnforceTypeConstraint(
             parser::FindSourceLocation(x), result, TypeCategory::Integer)) {
       ResetExpr(x);
       return std::nullopt;
     }
     return result;
   }
   template <typename A> MaybeExpr Analyze(const parser::Logical<A> &x) {
     auto result{Analyze(x.thing)};
     if (!EnforceTypeConstraint(
             parser::FindSourceLocation(x), result, TypeCategory::Logical)) {
       ResetExpr(x);
       return std::nullopt;
     }
     return result;
   }
   template <typename A> MaybeExpr Analyze(const parser::DefaultChar<A> &x) {
     auto result{Analyze(x.thing)};
     if (!EnforceTypeConstraint(parser::FindSourceLocation(x), result,
             TypeCategory::Character, true /* default kind */)) {
       ResetExpr(x);
       return std::nullopt;
     }
     return result;
   }
 
   MaybeExpr Analyze(const parser::Name &);
   MaybeExpr Analyze(const parser::DataRef &dr) {
     return Analyze<parser::DataRef>(dr);
   }
   MaybeExpr Analyze(const parser::StructureComponent &);
   MaybeExpr Analyze(const parser::SignedIntLiteralConstant &);
   MaybeExpr Analyze(const parser::SignedRealLiteralConstant &);
   MaybeExpr Analyze(const parser::SignedComplexLiteralConstant &);
   MaybeExpr Analyze(const parser::StructureConstructor &);
   MaybeExpr Analyze(const parser::InitialDataTarget &);
 
   void Analyze(const parser::CallStmt &);
   const Assignment *Analyze(const parser::AssignmentStmt &);
   const Assignment *Analyze(const parser::PointerAssignmentStmt &);
 
 protected:
   int IntegerTypeSpecKind(const parser::IntegerTypeSpec &);
 
 private:
   MaybeExpr Analyze(const parser::IntLiteralConstant &);
   MaybeExpr Analyze(const parser::RealLiteralConstant &);
   MaybeExpr Analyze(const parser::ComplexPart &);
   MaybeExpr Analyze(const parser::ComplexLiteralConstant &);
   MaybeExpr Analyze(const parser::LogicalLiteralConstant &);
   MaybeExpr Analyze(const parser::CharLiteralConstant &);
   MaybeExpr Analyze(const parser::HollerithLiteralConstant &);
   MaybeExpr Analyze(const parser::BOZLiteralConstant &);
   MaybeExpr Analyze(const parser::NamedConstant &);
   MaybeExpr Analyze(const parser::NullInit &);
   MaybeExpr Analyze(const parser::DataStmtConstant &);
   MaybeExpr Analyze(const parser::Substring &);
   MaybeExpr Analyze(const parser::ArrayElement &);
   MaybeExpr Analyze(const parser::CoindexedNamedObject &);
   MaybeExpr Analyze(const parser::CharLiteralConstantSubstring &);
   MaybeExpr Analyze(const parser::ArrayConstructor &);
   MaybeExpr Analyze(const parser::FunctionReference &,
       std::optional<parser::StructureConstructor> * = nullptr);
   MaybeExpr Analyze(const parser::Expr::Parentheses &);
   MaybeExpr Analyze(const parser::Expr::UnaryPlus &);
   MaybeExpr Analyze(const parser::Expr::Negate &);
   MaybeExpr Analyze(const parser::Expr::NOT &);
   MaybeExpr Analyze(const parser::Expr::PercentLoc &);
   MaybeExpr Analyze(const parser::Expr::DefinedUnary &);
   MaybeExpr Analyze(const parser::Expr::Power &);
   MaybeExpr Analyze(const parser::Expr::Multiply &);
   MaybeExpr Analyze(const parser::Expr::Divide &);
   MaybeExpr Analyze(const parser::Expr::Add &);
   MaybeExpr Analyze(const parser::Expr::Subtract &);
   MaybeExpr Analyze(const parser::Expr::ComplexConstructor &);
   MaybeExpr Analyze(const parser::Expr::Concat &);
   MaybeExpr Analyze(const parser::Expr::LT &);
   MaybeExpr Analyze(const parser::Expr::LE &);
   MaybeExpr Analyze(const parser::Expr::EQ &);
   MaybeExpr Analyze(const parser::Expr::NE &);
   MaybeExpr Analyze(const parser::Expr::GE &);
   MaybeExpr Analyze(const parser::Expr::GT &);
   MaybeExpr Analyze(const parser::Expr::AND &);
   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) {
           using Ty = std::decay_t<decltype(x)>;
           // Function references might turn out to be misparsed structure
           // constructors; we have to try generic procedure resolution
           // first to be sure.
           if constexpr (common::IsTypeInList<parser::StructureConstructor,
                             As...>) {
             std::optional<parser::StructureConstructor> ctor;
             MaybeExpr result;
             if constexpr (std::is_same_v<Ty,
                               common::Indirection<parser::FunctionReference>>) {
               result = Analyze(x.value(), &ctor);
             } else if constexpr (std::is_same_v<Ty,
                                      parser::FunctionReference>) {
               result = Analyze(x, &ctor);
             } else {
               return Analyze(x);
             }
             if (ctor) {
               // A misparsed function reference is really a structure
               // constructor.  Repair the parse tree in situ.
               const_cast<std::variant<As...> &>(u) = std::move(*ctor);
             }
             return result;
           }
           return Analyze(x);
         },
         u);
   }
 
   // Analysis subroutines
   int AnalyzeKindParam(
       const std::optional<parser::KindParam> &, int defaultKind);
   template <typename PARSED> MaybeExpr ExprOrVariable(const PARSED &);
   template <typename PARSED> MaybeExpr IntLiteralConstant(const PARSED &);
   MaybeExpr AnalyzeString(std::string &&, int kind);
   std::optional<Expr<SubscriptInteger>> AsSubscript(MaybeExpr &&);
   std::optional<Expr<SubscriptInteger>> TripletPart(
       const std::optional<parser::Subscript> &);
   std::optional<Subscript> AnalyzeSectionSubscript(
       const parser::SectionSubscript &);
   std::vector<Subscript> AnalyzeSectionSubscripts(
       const std::list<parser::SectionSubscript> &);
   MaybeExpr Designate(DataRef &&);
   MaybeExpr CompleteSubscripts(ArrayRef &&);
   MaybeExpr ApplySubscripts(DataRef &&, std::vector<Subscript> &&);
   MaybeExpr TopLevelChecks(DataRef &&);
   std::optional<Expr<SubscriptInteger>> GetSubstringBound(
       const std::optional<parser::ScalarIntExpr> &);
   MaybeExpr AnalyzeDefinedOp(const parser::Name &, ActualArguments &&);
 
   struct CalleeAndArguments {
     // A non-component function reference may constitute a misparsed
     // structure constructor, in which case its derived type's Symbol
     // will appear here.
     std::variant<ProcedureDesignator, SymbolRef> u;
     ActualArguments arguments;
   };
 
   std::optional<CalleeAndArguments> AnalyzeProcedureComponentRef(
       const parser::ProcComponentRef &, ActualArguments &&);
   std::optional<characteristics::Procedure> CheckCall(
       parser::CharBlock, const ProcedureDesignator &, ActualArguments &);
   using AdjustActuals =
       std::optional<std::function<bool(const Symbol &, ActualArguments &)>>;
   bool ResolveForward(const Symbol &);
   const Symbol *ResolveGeneric(const Symbol &, const ActualArguments &,
       const AdjustActuals &, bool mightBeStructureConstructor = false);
   void EmitGenericResolutionError(const Symbol &);
   std::optional<CalleeAndArguments> GetCalleeAndArguments(const parser::Name &,
       ActualArguments &&, bool isSubroutine = false,
       bool mightBeStructureConstructor = false);
   std::optional<CalleeAndArguments> GetCalleeAndArguments(
       const parser::ProcedureDesignator &, ActualArguments &&,
       bool isSubroutine, bool mightBeStructureConstructor = false);
 
   void CheckForBadRecursion(parser::CharBlock, const semantics::Symbol &);
   bool EnforceTypeConstraint(parser::CharBlock, const MaybeExpr &, TypeCategory,
       bool defaultKind = false);
   MaybeExpr MakeFunctionRef(
       parser::CharBlock, ProcedureDesignator &&, ActualArguments &&);
   MaybeExpr MakeFunctionRef(parser::CharBlock intrinsic, ActualArguments &&);
   template <typename T> T Fold(T &&expr) {
     return evaluate::Fold(foldingContext_, std::move(expr));
   }
 
   semantics::SemanticsContext &context_;
   FoldingContext &foldingContext_{context_.foldingContext()};
   std::map<parser::CharBlock, int> impliedDos_; // values are INTEGER kinds
   bool fatalErrors_{false};
   friend class ArgumentAnalyzer;
 };
 
 inline bool AreConformable(int leftRank, int rightRank) {
   return leftRank == 0 || rightRank == 0 || leftRank == rightRank;
 }
 
 template <typename L, typename R>
 bool AreConformable(const L &left, const R &right) {
   return AreConformable(left.Rank(), right.Rank());
 }
 
 template <typename L, typename R>
 void ConformabilityCheck(
     parser::ContextualMessages &context, const L &left, const R &right) {
   if (!AreConformable(left, right)) {
     context.Say("left operand has rank %d, right operand has rank %d"_err_en_US,
         left.Rank(), right.Rank());
   }
 }
 } // namespace Fortran::evaluate
 
 namespace Fortran::semantics {
 
 // Semantic analysis of one expression, variable, or designator.
 template <typename A>
 std::optional<evaluate::Expr<evaluate::SomeType>> AnalyzeExpr(
     SemanticsContext &context, const A &expr) {
   return evaluate::ExpressionAnalyzer{context}.Analyze(expr);
 }
 
 // Semantic analysis of an intrinsic type's KIND parameter expression.
 evaluate::Expr<evaluate::SubscriptInteger> AnalyzeKindSelector(
     SemanticsContext &, common::TypeCategory,
     const std::optional<parser::KindSelector> &);
 
 void AnalyzeCallStmt(SemanticsContext &, const parser::CallStmt &);
 const evaluate::Assignment *AnalyzeAssignmentStmt(
     SemanticsContext &, const parser::AssignmentStmt &);
 const evaluate::Assignment *AnalyzePointerAssignmentStmt(
     SemanticsContext &, const parser::PointerAssignmentStmt &);
 
 // Semantic analysis of all expressions in a parse tree, which becomes
 // decorated with typed representations for top-level expressions.
 class ExprChecker {
 public:
   explicit ExprChecker(SemanticsContext &);
 
   template <typename A> bool Pre(const A &) { return true; }
   template <typename A> void Post(const A &) {}
   bool Walk(const parser::Program &);
 
   bool Pre(const parser::Expr &x) {
     exprAnalyzer_.Analyze(x);
     return false;
   }
   bool Pre(const parser::Variable &x) {
     exprAnalyzer_.Analyze(x);
     return false;
   }
   bool Pre(const parser::DataStmtValue &x) {
     exprAnalyzer_.Analyze(x);
     return false;
   }
   bool Pre(const parser::DataImpliedDo &);
 
   bool Pre(const parser::CallStmt &x) {
     AnalyzeCallStmt(context_, x);
     return false;
   }
   bool Pre(const parser::AssignmentStmt &x) {
     AnalyzeAssignmentStmt(context_, x);
     return false;
   }
   bool Pre(const parser::PointerAssignmentStmt &x) {
     AnalyzePointerAssignmentStmt(context_, x);
     return false;
   }
 
   template <typename A> bool Pre(const parser::Scalar<A> &x) {
     exprAnalyzer_.Analyze(x);
     return false;
   }
   template <typename A> bool Pre(const parser::Constant<A> &x) {
     exprAnalyzer_.Analyze(x);
     return false;
   }
   template <typename A> bool Pre(const parser::Integer<A> &x) {
     exprAnalyzer_.Analyze(x);
     return false;
   }
   template <typename A> bool Pre(const parser::Logical<A> &x) {
     exprAnalyzer_.Analyze(x);
     return false;
   }
   template <typename A> bool Pre(const parser::DefaultChar<A> &x) {
     exprAnalyzer_.Analyze(x);
     return false;
   }
 
 private:
   SemanticsContext &context_;
   evaluate::ExpressionAnalyzer exprAnalyzer_{context_};
 };
 } // namespace Fortran::semantics
 #endif // FORTRAN_SEMANTICS_EXPRESSION_H_
diff --git a/flang/include/flang/Semantics/semantics.h b/flang/include/flang/Semantics/semantics.h
index 0c60a98cd562..b6fdb35bdb08 100644
--- a/flang/include/flang/Semantics/semantics.h
+++ b/flang/include/flang/Semantics/semantics.h
@@ -1,232 +1,232 @@
 //===-- include/flang/Semantics/semantics.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_SEMANTICS_H_
 #define FORTRAN_SEMANTICS_SEMANTICS_H_
 
 #include "scope.h"
 #include "symbol.h"
 #include "flang/Common/Fortran-features.h"
 #include "flang/Evaluate/common.h"
 #include "flang/Evaluate/intrinsics.h"
 #include "flang/Parser/message.h"
 #include <iosfwd>
 #include <string>
 #include <vector>
 
 namespace llvm {
 class raw_ostream;
 }
 
 namespace Fortran::common {
 class IntrinsicTypeDefaultKinds;
 }
 
 namespace Fortran::parser {
 struct Name;
 struct Program;
 class CookedSource;
 struct AssociateConstruct;
 struct BlockConstruct;
 struct CaseConstruct;
 struct DoConstruct;
 struct ChangeTeamConstruct;
 struct CriticalConstruct;
 struct ForallConstruct;
 struct IfConstruct;
 struct SelectRankConstruct;
 struct SelectTypeConstruct;
 struct Variable;
 struct WhereConstruct;
 } // namespace Fortran::parser
 
 namespace Fortran::semantics {
 
 class Symbol;
 
 using ConstructNode = std::variant<const parser::AssociateConstruct *,
     const parser::BlockConstruct *, const parser::CaseConstruct *,
     const parser::ChangeTeamConstruct *, const parser::CriticalConstruct *,
     const parser::DoConstruct *, const parser::ForallConstruct *,
     const parser::IfConstruct *, const parser::SelectRankConstruct *,
     const parser::SelectTypeConstruct *, const parser::WhereConstruct *>;
 using ConstructStack = std::vector<ConstructNode>;
 
 class SemanticsContext {
 public:
   SemanticsContext(const common::IntrinsicTypeDefaultKinds &,
       const common::LanguageFeatureControl &, parser::AllSources &);
   ~SemanticsContext();
 
   const common::IntrinsicTypeDefaultKinds &defaultKinds() const {
     return defaultKinds_;
   }
   const common::LanguageFeatureControl &languageFeatures() const {
     return languageFeatures_;
   };
   int GetDefaultKind(TypeCategory) const;
   int doublePrecisionKind() const {
     return defaultKinds_.doublePrecisionKind();
   }
   int quadPrecisionKind() const { return defaultKinds_.quadPrecisionKind(); }
   bool IsEnabled(common::LanguageFeature) const;
   bool ShouldWarn(common::LanguageFeature) const;
   const std::optional<parser::CharBlock> &location() const { return location_; }
   const std::vector<std::string> &searchDirectories() const {
     return searchDirectories_;
   }
   const std::string &moduleDirectory() const { return moduleDirectory_; }
   const std::string &moduleFileSuffix() const { return moduleFileSuffix_; }
   bool warnOnNonstandardUsage() const { return warnOnNonstandardUsage_; }
   bool warningsAreErrors() const { return warningsAreErrors_; }
   bool debugModuleWriter() const { return debugModuleWriter_; }
   const evaluate::IntrinsicProcTable &intrinsics() const { return intrinsics_; }
   Scope &globalScope() { return globalScope_; }
   parser::Messages &messages() { return messages_; }
   evaluate::FoldingContext &foldingContext() { return foldingContext_; }
   parser::AllSources &allSources() { return allSources_; }
 
   SemanticsContext &set_location(
       const std::optional<parser::CharBlock> &location) {
     location_ = location;
     return *this;
   }
   SemanticsContext &set_searchDirectories(const std::vector<std::string> &x) {
     searchDirectories_ = x;
     return *this;
   }
   SemanticsContext &set_moduleDirectory(const std::string &x) {
     moduleDirectory_ = x;
     return *this;
   }
   SemanticsContext &set_moduleFileSuffix(const std::string &x) {
     moduleFileSuffix_ = x;
     return *this;
   }
   SemanticsContext &set_warnOnNonstandardUsage(bool x) {
     warnOnNonstandardUsage_ = x;
     return *this;
   }
   SemanticsContext &set_warningsAreErrors(bool x) {
     warningsAreErrors_ = x;
     return *this;
   }
 
   SemanticsContext &set_debugModuleWriter(bool x) {
     debugModuleWriter_ = x;
     return *this;
   }
 
   const DeclTypeSpec &MakeNumericType(TypeCategory, int kind = 0);
   const DeclTypeSpec &MakeLogicalType(int kind = 0);
 
   bool AnyFatalError() const;
 
   // Test or set the Error flag on a Symbol
   bool HasError(const Symbol &);
   bool HasError(const Symbol *);
   bool HasError(const parser::Name &);
   void SetError(Symbol &, bool = true);
 
-  template <typename... A> parser::Message &Say(A &&... args) {
+  template <typename... A> parser::Message &Say(A &&...args) {
     CHECK(location_);
     return messages_.Say(*location_, std::forward<A>(args)...);
   }
   template <typename... A>
-  parser::Message &Say(parser::CharBlock at, A &&... args) {
+  parser::Message &Say(parser::CharBlock at, A &&...args) {
     return messages_.Say(at, std::forward<A>(args)...);
   }
   parser::Message &Say(parser::Message &&msg) {
     return messages_.Say(std::move(msg));
   }
   template <typename... A>
   void SayWithDecl(const Symbol &symbol, const parser::CharBlock &at,
-      parser::MessageFixedText &&msg, A &&... args) {
+      parser::MessageFixedText &&msg, A &&...args) {
     auto &message{Say(at, std::move(msg), args...)};
     evaluate::AttachDeclaration(&message, symbol);
   }
 
   const Scope &FindScope(parser::CharBlock) const;
   Scope &FindScope(parser::CharBlock);
 
   const ConstructStack &constructStack() const { return constructStack_; }
   template <typename N> void PushConstruct(const N &node) {
     constructStack_.emplace_back(&node);
   }
   void PopConstruct();
 
   ENUM_CLASS(IndexVarKind, DO, FORALL)
   // Check to see if a variable being redefined is a DO or FORALL index.
   // If so, emit a message.
   void WarnIndexVarRedefine(const parser::CharBlock &, const Symbol &);
   void CheckIndexVarRedefine(const parser::CharBlock &, const Symbol &);
   void CheckIndexVarRedefine(const parser::Variable &);
   void CheckIndexVarRedefine(const parser::Name &);
   void ActivateIndexVar(const parser::Name &, IndexVarKind);
   void DeactivateIndexVar(const parser::Name &);
   SymbolVector GetIndexVars(IndexVarKind);
 
 private:
   void CheckIndexVarRedefine(
       const parser::CharBlock &, const Symbol &, parser::MessageFixedText &&);
   bool CheckError(bool);
 
   const common::IntrinsicTypeDefaultKinds &defaultKinds_;
   const common::LanguageFeatureControl languageFeatures_;
   parser::AllSources &allSources_;
   std::optional<parser::CharBlock> location_;
   std::vector<std::string> searchDirectories_;
   std::string moduleDirectory_{"."s};
   std::string moduleFileSuffix_{".mod"};
   bool warnOnNonstandardUsage_{false};
   bool warningsAreErrors_{false};
   bool debugModuleWriter_{false};
   const evaluate::IntrinsicProcTable intrinsics_;
   Scope globalScope_;
   parser::Messages messages_;
   evaluate::FoldingContext foldingContext_;
   ConstructStack constructStack_;
   struct IndexVarInfo {
     parser::CharBlock location;
     IndexVarKind kind;
   };
   std::map<SymbolRef, const IndexVarInfo> activeIndexVars_;
 };
 
 class Semantics {
 public:
   explicit Semantics(SemanticsContext &context, parser::Program &program,
       parser::CookedSource &cooked, bool debugModuleWriter = false)
       : context_{context}, program_{program}, cooked_{cooked} {
     context.set_debugModuleWriter(debugModuleWriter);
     context.globalScope().AddSourceRange(parser::CharBlock{cooked.data()});
   }
 
   SemanticsContext &context() const { return context_; }
   bool Perform();
   const Scope &FindScope(const parser::CharBlock &where) const {
     return context_.FindScope(where);
   }
   bool AnyFatalError() const { return context_.AnyFatalError(); }
   void EmitMessages(llvm::raw_ostream &) const;
   void DumpSymbols(llvm::raw_ostream &);
   void DumpSymbolsSources(llvm::raw_ostream &) const;
 
 private:
   SemanticsContext &context_;
   parser::Program &program_;
   const parser::CookedSource &cooked_;
 };
 
 // Base class for semantics checkers.
 struct BaseChecker {
   template <typename N> void Enter(const N &) {}
   template <typename N> void Leave(const N &) {}
 };
 } // namespace Fortran::semantics
 #endif
diff --git a/flang/lib/Evaluate/intrinsics-library-templates.h b/flang/lib/Evaluate/intrinsics-library-templates.h
index 8accd2bbbd28..569e200b6b93 100644
--- a/flang/lib/Evaluate/intrinsics-library-templates.h
+++ b/flang/lib/Evaluate/intrinsics-library-templates.h
@@ -1,209 +1,209 @@
 //===-- lib/Evaluate/intrinsics-library-templates.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_EVALUATE_INTRINSICS_LIBRARY_TEMPLATES_H_
 #define FORTRAN_EVALUATE_INTRINSICS_LIBRARY_TEMPLATES_H_
 
 // This header defines the actual implementation of the templatized member
 // function of the structures defined in intrinsics-library.h. It should only be
 // included if these member functions are used, else intrinsics-library.h is
 // sufficient. This is to avoid circular dependencies. The below implementation
 // cannot be defined in .cpp file because it would be too cumbersome to decide
 // which version should be instantiated in a generic way.
 
 #include "host.h"
 #include "flang/Common/template.h"
 #include "flang/Evaluate/intrinsics-library.h"
 #include "flang/Evaluate/type.h"
 
 #include <tuple>
 #include <type_traits>
 
 namespace Fortran::evaluate {
 
 // Define meaningful types for the runtime
 using RuntimeTypes = evaluate::AllIntrinsicTypes;
 
 template <typename T, typename... TT> struct IndexInTupleHelper {};
 template <typename T, typename... TT>
 struct IndexInTupleHelper<T, std::tuple<TT...>> {
   static constexpr TypeCode value{common::TypeIndex<T, TT...>};
 };
 
 static_assert(
     std::tuple_size_v<RuntimeTypes> < std::numeric_limits<TypeCode>::max(),
     "TypeCode is too small");
 template <typename T>
 inline constexpr TypeCode typeCodeOf{
     IndexInTupleHelper<T, RuntimeTypes>::value};
 
 template <TypeCode n>
 using RuntimeTypeOf = typename std::tuple_element_t<n, RuntimeTypes>;
 
 template <typename TA, PassBy Pass>
 using HostArgType = std::conditional_t<Pass == PassBy::Ref,
     std::add_lvalue_reference_t<std::add_const_t<host::HostType<TA>>>,
     host::HostType<TA>>;
 
 template <typename TR, typename... ArgInfo>
 using HostFuncPointer = FuncPointer<host::HostType<TR>,
     HostArgType<typename ArgInfo::Type, ArgInfo::pass>...>;
 
 // Software Subnormal Flushing helper.
 template <typename T> struct Flusher {
   // Only flush floating-points. Forward other scalars untouched.
   static constexpr inline const Scalar<T> &FlushSubnormals(const Scalar<T> &x) {
     return x;
   }
 };
 template <int Kind> struct Flusher<Type<TypeCategory::Real, Kind>> {
   using T = Type<TypeCategory::Real, Kind>;
   static constexpr inline Scalar<T> FlushSubnormals(const Scalar<T> &x) {
     return x.FlushSubnormalToZero();
   }
 };
 template <int Kind> struct Flusher<Type<TypeCategory::Complex, Kind>> {
   using T = Type<TypeCategory::Complex, Kind>;
   static constexpr inline Scalar<T> FlushSubnormals(const Scalar<T> &x) {
     return x.FlushSubnormalToZero();
   }
 };
 
 // Callable factory
 template <typename TR, typename... ArgInfo> struct CallableHostWrapper {
   static Scalar<TR> scalarCallable(FoldingContext &context,
       HostFuncPointer<TR, ArgInfo...> func,
-      const Scalar<typename ArgInfo::Type> &... x) {
+      const Scalar<typename ArgInfo::Type> &...x) {
     if constexpr (host::HostTypeExists<TR, typename ArgInfo::Type...>()) {
       host::HostFloatingPointEnvironment hostFPE;
       hostFPE.SetUpHostFloatingPointEnvironment(context);
       host::HostType<TR> hostResult{};
       Scalar<TR> result{};
       if (context.flushSubnormalsToZero() &&
           !hostFPE.hasSubnormalFlushingHardwareControl()) {
         hostResult = func(host::CastFortranToHost<typename ArgInfo::Type>(
             Flusher<typename ArgInfo::Type>::FlushSubnormals(x))...);
         result = Flusher<TR>::FlushSubnormals(
             host::CastHostToFortran<TR>(hostResult));
       } else {
         hostResult =
             func(host::CastFortranToHost<typename ArgInfo::Type>(x)...);
         result = host::CastHostToFortran<TR>(hostResult);
       }
       if (!hostFPE.hardwareFlagsAreReliable()) {
         CheckFloatingPointIssues(hostFPE, result);
       }
       hostFPE.CheckAndRestoreFloatingPointEnvironment(context);
       return result;
     } else {
       common::die("Internal error: Host does not supports this function type."
                   "This should not have been called for folding");
     }
   }
   static constexpr inline auto MakeScalarCallable() { return &scalarCallable; }
 
   static void CheckFloatingPointIssues(
       host::HostFloatingPointEnvironment &hostFPE, const Scalar<TR> &x) {
     if constexpr (TR::category == TypeCategory::Complex ||
         TR::category == TypeCategory::Real) {
       if (x.IsNotANumber()) {
         hostFPE.SetFlag(RealFlag::InvalidArgument);
       } else if (x.IsInfinite()) {
         hostFPE.SetFlag(RealFlag::Overflow);
       }
     }
   }
 };
 
 template <typename TR, typename... TA>
 inline GenericFunctionPointer ToGenericFunctionPointer(
     FuncPointer<TR, TA...> f) {
   return reinterpret_cast<GenericFunctionPointer>(f);
 }
 
 template <typename TR, typename... TA>
 inline FuncPointer<TR, TA...> FromGenericFunctionPointer(
     GenericFunctionPointer g) {
   return reinterpret_cast<FuncPointer<TR, TA...>>(g);
 }
 
 template <typename TR, typename... ArgInfo>
 IntrinsicProcedureRuntimeDescription::IntrinsicProcedureRuntimeDescription(
     const Signature<TR, ArgInfo...> &signature, bool isElemental)
     : name{signature.name}, returnType{typeCodeOf<TR>},
       argumentsType{typeCodeOf<typename ArgInfo::Type>...},
       argumentsPassedBy{ArgInfo::pass...}, isElemental{isElemental},
       callable{ToGenericFunctionPointer(
           CallableHostWrapper<TR, ArgInfo...>::MakeScalarCallable())} {}
 
 template <typename HostTA> static constexpr inline PassBy PassByMethod() {
   if constexpr (std::is_pointer_v<std::decay_t<HostTA>> ||
       std::is_lvalue_reference_v<HostTA>) {
     return PassBy::Ref;
   }
   return PassBy::Val;
 }
 
 template <typename HostTA>
 using ArgInfoFromHostType =
     ArgumentInfo<host::FortranType<std::remove_pointer_t<std::decay_t<HostTA>>>,
         PassByMethod<HostTA>()>;
 
 template <typename HostTR, typename... HostTA>
 using SignatureFromHostFuncPointer =
     Signature<host::FortranType<HostTR>, ArgInfoFromHostType<HostTA>...>;
 
 template <typename HostTR, typename... HostTA>
 HostRuntimeIntrinsicProcedure::HostRuntimeIntrinsicProcedure(
     const std::string &name, FuncPointer<HostTR, HostTA...> func,
     bool isElemental)
     : IntrinsicProcedureRuntimeDescription(
           SignatureFromHostFuncPointer<HostTR, HostTA...>{name}, isElemental),
       handle{ToGenericFunctionPointer(func)} {}
 
 template <template <typename> typename ConstantContainer, typename TR,
     typename... TA>
 std::optional<HostProcedureWrapper<ConstantContainer, TR, TA...>>
 HostIntrinsicProceduresLibrary::GetHostProcedureWrapper(
     const std::string &name) const {
   if constexpr (host::HostTypeExists<TR, TA...>()) {
     auto rteProcRange{procedures_.equal_range(name)};
     const TypeCode resTypeCode{typeCodeOf<TR>};
     const std::vector<TypeCode> argTypes{typeCodeOf<TA>...};
     const size_t nargs{argTypes.size()};
     for (auto iter{rteProcRange.first}; iter != rteProcRange.second; ++iter) {
       if (nargs == iter->second.argumentsType.size() &&
           resTypeCode == iter->second.returnType &&
           (!std::is_same_v<ConstantContainer<TR>, Scalar<TR>> ||
               iter->second.isElemental)) {
         bool match{true};
         int pos{0};
         for (auto const &type : argTypes) {
           if (type != iter->second.argumentsType[pos++]) {
             match = false;
             break;
           }
         }
         if (match) {
           return {HostProcedureWrapper<ConstantContainer, TR, TA...>{
               [=](FoldingContext &context,
-                  const ConstantContainer<TA> &... args) {
+                  const ConstantContainer<TA> &...args) {
                 auto callable{FromGenericFunctionPointer<ConstantContainer<TR>,
                     FoldingContext &, GenericFunctionPointer,
                     const ConstantContainer<TA> &...>(iter->second.callable)};
                 return callable(context, iter->second.handle, args...);
               }}};
         }
       }
     }
   }
   return std::nullopt;
 }
 
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_INTRINSICS_LIBRARY_TEMPLATES_H_
diff --git a/flang/lib/Parser/basic-parsers.h b/flang/lib/Parser/basic-parsers.h
index 6d88e5277fbe..300400517507 100644
--- a/flang/lib/Parser/basic-parsers.h
+++ b/flang/lib/Parser/basic-parsers.h
@@ -1,926 +1,926 @@
 //===-- lib/Parser/basic-parsers.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_BASIC_PARSERS_H_
 #define FORTRAN_PARSER_BASIC_PARSERS_H_
 
 // Let a "parser" be an instance of any class that supports this
 // type definition and member (or static) function:
 //
 //   using resultType = ...;
 //   std::optional<resultType> Parse(ParseState &) const;
 //
 // which either returns a value to signify a successful recognition or else
 // returns {} to signify failure.  On failure, the state cannot be assumed
 // to still be valid, in general -- see below for exceptions.
 //
 // This header defines the fundamental parser class templates and helper
 // template functions.  See parser-combinators.txt for documentation.
 
 #include "flang/Common/Fortran-features.h"
 #include "flang/Common/idioms.h"
 #include "flang/Common/indirection.h"
 #include "flang/Parser/char-block.h"
 #include "flang/Parser/message.h"
 #include "flang/Parser/parse-state.h"
 #include "flang/Parser/provenance.h"
 #include "flang/Parser/user-state.h"
 #include <cstring>
 #include <functional>
 #include <list>
 #include <memory>
 #include <optional>
 #include <string>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 
 namespace Fortran::parser {
 
 // fail<A>("..."_err_en_US) returns a parser that never succeeds.  It reports an
 // error message at the current position.  The result type is unused,
 // but might have to be specified at the point of call to satisfy
 // the type checker.  The state remains valid.
 template <typename A> class FailParser {
 public:
   using resultType = A;
   constexpr FailParser(const FailParser &) = default;
   constexpr explicit FailParser(MessageFixedText t) : text_{t} {}
   std::optional<A> Parse(ParseState &state) const {
     state.Say(text_);
     return std::nullopt;
   }
 
 private:
   const MessageFixedText text_;
 };
 
 template <typename A = Success> inline constexpr auto fail(MessageFixedText t) {
   return FailParser<A>{t};
 }
 
 // pure(x) returns a parser that always succeeds, does not advance the
 // parse, and returns a captured value x whose type must be copy-constructible.
 //
 // pure<A>() is essentially pure(A{}); it returns a default-constructed A{},
 // and works even when A is not copy-constructible.
 template <typename A> class PureParser {
 public:
   using resultType = A;
   constexpr PureParser(const PureParser &) = default;
   constexpr explicit PureParser(A &&x) : value_(std::move(x)) {}
   std::optional<A> Parse(ParseState &) const { return value_; }
 
 private:
   const A value_;
 };
 
 template <typename A> inline constexpr auto pure(A x) {
   return PureParser<A>(std::move(x));
 }
 
 template <typename A> class PureDefaultParser {
 public:
   using resultType = A;
   constexpr PureDefaultParser(const PureDefaultParser &) = default;
   constexpr PureDefaultParser() {}
   std::optional<A> Parse(ParseState &) const { return std::make_optional<A>(); }
 };
 
 template <typename A> inline constexpr auto pure() {
   return PureDefaultParser<A>();
 }
 
 // If a is a parser, attempt(a) is the same parser, but on failure
 // the ParseState is guaranteed to have been restored to its initial value.
 template <typename A> class BacktrackingParser {
 public:
   using resultType = typename A::resultType;
   constexpr BacktrackingParser(const BacktrackingParser &) = default;
   constexpr BacktrackingParser(const A &parser) : parser_{parser} {}
   std::optional<resultType> Parse(ParseState &state) const {
     Messages messages{std::move(state.messages())};
     ParseState backtrack{state};
     std::optional<resultType> result{parser_.Parse(state)};
     if (result) {
       state.messages().Restore(std::move(messages));
     } else {
       state = std::move(backtrack);
       state.messages() = std::move(messages);
     }
     return result;
   }
 
 private:
   const A parser_;
 };
 
 template <typename A> inline constexpr auto attempt(const A &parser) {
   return BacktrackingParser<A>{parser};
 }
 
 // For any parser x, the parser returned by !x is one that succeeds when
 // x fails, returning a useless (but present) result.  !x fails when x succeeds.
 template <typename PA> class NegatedParser {
 public:
   using resultType = Success;
   constexpr NegatedParser(const NegatedParser &) = default;
   constexpr NegatedParser(PA p) : parser_{p} {}
   std::optional<Success> Parse(ParseState &state) const {
     ParseState forked{state};
     forked.set_deferMessages(true);
     if (parser_.Parse(forked)) {
       return std::nullopt;
     }
     return Success{};
   }
 
 private:
   const PA parser_;
 };
 
 template <typename PA, typename = typename PA::resultType>
 constexpr auto operator!(PA p) {
   return NegatedParser<PA>(p);
 }
 
 // For any parser x, the parser returned by lookAhead(x) is one that succeeds
 // or fails if x does, but the state is not modified.
 template <typename PA> class LookAheadParser {
 public:
   using resultType = Success;
   constexpr LookAheadParser(const LookAheadParser &) = default;
   constexpr LookAheadParser(PA p) : parser_{p} {}
   std::optional<Success> Parse(ParseState &state) const {
     ParseState forked{state};
     forked.set_deferMessages(true);
     if (parser_.Parse(forked)) {
       return Success{};
     }
     return std::nullopt;
   }
 
 private:
   const PA parser_;
 };
 
 template <typename PA> inline constexpr auto lookAhead(PA p) {
   return LookAheadParser<PA>{p};
 }
 
 // If a is a parser, inContext("..."_en_US, a) runs it in a nested message
 // context.
 template <typename PA> class MessageContextParser {
 public:
   using resultType = typename PA::resultType;
   constexpr MessageContextParser(const MessageContextParser &) = default;
   constexpr MessageContextParser(MessageFixedText t, PA p)
       : text_{t}, parser_{p} {}
   std::optional<resultType> Parse(ParseState &state) const {
     state.PushContext(text_);
     std::optional<resultType> result{parser_.Parse(state)};
     state.PopContext();
     return result;
   }
 
 private:
   const MessageFixedText text_;
   const PA parser_;
 };
 
 template <typename PA>
 inline constexpr auto inContext(MessageFixedText context, PA parser) {
   return MessageContextParser{context, parser};
 }
 
 // If a is a parser, withMessage("..."_en_US, a) runs it unchanged if it
 // succeeds, and overrides its messages with a specific one if it fails and
 // has matched no tokens.
 template <typename PA> class WithMessageParser {
 public:
   using resultType = typename PA::resultType;
   constexpr WithMessageParser(const WithMessageParser &) = default;
   constexpr WithMessageParser(MessageFixedText t, PA p)
       : text_{t}, parser_{p} {}
   std::optional<resultType> Parse(ParseState &state) const {
     Messages messages{std::move(state.messages())};
     ParseState backtrack{state};
     state.set_anyTokenMatched(false);
     std::optional<resultType> result{parser_.Parse(state)};
     bool emitMessage{false};
     if (result) {
       messages.Annex(std::move(state.messages()));
       if (backtrack.anyTokenMatched()) {
         state.set_anyTokenMatched();
       }
     } else if (state.anyTokenMatched()) {
       emitMessage = state.messages().empty();
       messages.Annex(std::move(state.messages()));
       backtrack.set_anyTokenMatched();
       if (state.anyDeferredMessages()) {
         backtrack.set_anyDeferredMessages(true);
       }
       state = std::move(backtrack);
     } else {
       emitMessage = true;
     }
     state.messages() = std::move(messages);
     if (emitMessage) {
       state.Say(text_);
     }
     return result;
   }
 
 private:
   const MessageFixedText text_;
   const PA parser_;
 };
 
 template <typename PA>
 inline constexpr auto withMessage(MessageFixedText msg, PA parser) {
   return WithMessageParser{msg, parser};
 }
 
 // If a and b are parsers, then a >> b returns a parser that succeeds when
 // b succeeds after a does so, but fails when either a or b does.  The
 // result is taken from b.  Similarly, a / b also succeeds if both a and b
 // do so, but the result is that returned by a.
 template <typename PA, typename PB> class SequenceParser {
 public:
   using resultType = typename PB::resultType;
   constexpr SequenceParser(const SequenceParser &) = default;
   constexpr SequenceParser(PA pa, PB pb) : pa_{pa}, pb2_{pb} {}
   std::optional<resultType> Parse(ParseState &state) const {
     if (pa_.Parse(state)) {
       return pb2_.Parse(state);
     } else {
       return std::nullopt;
     }
   }
 
 private:
   const PA pa_;
   const PB pb2_;
 };
 
 template <typename PA, typename PB>
 inline constexpr auto operator>>(PA pa, PB pb) {
   return SequenceParser<PA, PB>{pa, pb};
 }
 
 template <typename PA, typename PB> class FollowParser {
 public:
   using resultType = typename PA::resultType;
   constexpr FollowParser(const FollowParser &) = default;
   constexpr FollowParser(PA pa, PB pb) : pa_{pa}, pb_{pb} {}
   std::optional<resultType> Parse(ParseState &state) const {
     if (std::optional<resultType> ax{pa_.Parse(state)}) {
       if (pb_.Parse(state)) {
         return ax;
       }
     }
     return std::nullopt;
   }
 
 private:
   const PA pa_;
   const PB pb_;
 };
 
 template <typename PA, typename PB>
 inline constexpr auto operator/(PA pa, PB pb) {
   return FollowParser<PA, PB>{pa, pb};
 }
 
 template <typename PA, typename... Ps> class AlternativesParser {
 public:
   using resultType = typename PA::resultType;
   constexpr AlternativesParser(PA pa, Ps... ps) : ps_{pa, ps...} {}
   constexpr AlternativesParser(const AlternativesParser &) = default;
   std::optional<resultType> Parse(ParseState &state) const {
     Messages messages{std::move(state.messages())};
     ParseState backtrack{state};
     std::optional<resultType> result{std::get<0>(ps_).Parse(state)};
     if constexpr (sizeof...(Ps) > 0) {
       if (!result) {
         ParseRest<1>(result, state, backtrack);
       }
     }
     state.messages().Restore(std::move(messages));
     return result;
   }
 
 private:
   template <int J>
   void ParseRest(std::optional<resultType> &result, ParseState &state,
       ParseState &backtrack) const {
     ParseState prevState{std::move(state)};
     state = backtrack;
     result = std::get<J>(ps_).Parse(state);
     if (!result) {
       state.CombineFailedParses(std::move(prevState));
       if constexpr (J < sizeof...(Ps)) {
         ParseRest<J + 1>(result, state, backtrack);
       }
     }
   }
 
   const std::tuple<PA, Ps...> ps_;
 };
 
 template <typename... Ps> inline constexpr auto first(Ps... ps) {
   return AlternativesParser<Ps...>{ps...};
 }
 
 template <typename PA, typename PB>
 inline constexpr auto operator||(PA pa, PB pb) {
   return AlternativesParser<PA, PB>{pa, pb};
 }
 
 // If a and b are parsers, then recovery(a,b) returns a parser that succeeds if
 // a does so, or if a fails and b succeeds.  If a succeeds, b is not attempted.
 // All messages from the first parse are retained.
 // The two parsers must return values of the same type.
 template <typename PA, typename PB> class RecoveryParser {
 public:
   using resultType = typename PA::resultType;
   static_assert(std::is_same_v<resultType, typename PB::resultType>);
   constexpr RecoveryParser(const RecoveryParser &) = default;
   constexpr RecoveryParser(PA pa, PB pb) : pa_{pa}, pb3_{pb} {}
   std::optional<resultType> Parse(ParseState &state) const {
     bool originallyDeferred{state.deferMessages()};
     ParseState backtrack{state};
     if (!originallyDeferred && state.messages().empty() &&
         !state.anyErrorRecovery()) {
       // Fast path.  There are no messages or recovered errors in the incoming
       // state.  Attempt to parse with messages deferred, expecting that the
       // parse will succeed silently.
       state.set_deferMessages(true);
       if (std::optional<resultType> ax{pa_.Parse(state)}) {
         if (!state.anyDeferredMessages() && !state.anyErrorRecovery()) {
           state.set_deferMessages(false);
           return ax;
         }
       }
       state = backtrack;
     }
     Messages messages{std::move(state.messages())};
     if (std::optional<resultType> ax{pa_.Parse(state)}) {
       state.messages().Restore(std::move(messages));
       return ax;
     }
     messages.Annex(std::move(state.messages()));
     bool hadDeferredMessages{state.anyDeferredMessages()};
     bool anyTokenMatched{state.anyTokenMatched()};
     state = std::move(backtrack);
     state.set_deferMessages(true);
     std::optional<resultType> bx{pb3_.Parse(state)};
     state.messages() = std::move(messages);
     state.set_deferMessages(originallyDeferred);
     if (anyTokenMatched) {
       state.set_anyTokenMatched();
     }
     if (hadDeferredMessages) {
       state.set_anyDeferredMessages();
     }
     if (bx) {
       // Error recovery situations must also produce messages.
       CHECK(state.anyDeferredMessages() || state.messages().AnyFatalError());
       state.set_anyErrorRecovery();
     }
     return bx;
   }
 
 private:
   const PA pa_;
   const PB pb3_;
 };
 
 template <typename PA, typename PB>
 inline constexpr auto recovery(PA pa, PB pb) {
   return RecoveryParser<PA, PB>{pa, pb};
 }
 
 // If x is a parser, then many(x) returns a parser that always succeeds
 // and whose value is a list, possibly empty, of the values returned from
 // repeated application of x until it fails or does not advance the parse.
 template <typename PA> class ManyParser {
   using paType = typename PA::resultType;
 
 public:
   using resultType = std::list<paType>;
   constexpr ManyParser(const ManyParser &) = default;
   constexpr ManyParser(PA parser) : parser_{parser} {}
   std::optional<resultType> Parse(ParseState &state) const {
     resultType result;
     auto at{state.GetLocation()};
     while (std::optional<paType> x{parser_.Parse(state)}) {
       result.emplace_back(std::move(*x));
       if (state.GetLocation() <= at) {
         break; // no forward progress, don't loop
       }
       at = state.GetLocation();
     }
     return {std::move(result)};
   }
 
 private:
   const BacktrackingParser<PA> parser_;
 };
 
 template <typename PA> inline constexpr auto many(PA parser) {
   return ManyParser<PA>{parser};
 }
 
 // If x is a parser, then some(x) returns a parser that succeeds if x does
 // and whose value is a nonempty list of the values returned from repeated
 // application of x until it fails or does not advance the parse.  In other
 // words, some(x) is a variant of many(x) that has to succeed at least once.
 template <typename PA> class SomeParser {
   using paType = typename PA::resultType;
 
 public:
   using resultType = std::list<paType>;
   constexpr SomeParser(const SomeParser &) = default;
   constexpr SomeParser(PA parser) : parser_{parser} {}
   std::optional<resultType> Parse(ParseState &state) const {
     auto start{state.GetLocation()};
     if (std::optional<paType> first{parser_.Parse(state)}) {
       resultType result;
       result.emplace_back(std::move(*first));
       if (state.GetLocation() > start) {
         result.splice(result.end(), many(parser_).Parse(state).value());
       }
       return {std::move(result)};
     }
     return std::nullopt;
   }
 
 private:
   const PA parser_;
 };
 
 template <typename PA> inline constexpr auto some(PA parser) {
   return SomeParser<PA>{parser};
 }
 
 // If x is a parser, skipMany(x) is equivalent to many(x) but with no result.
 template <typename PA> class SkipManyParser {
 public:
   using resultType = Success;
   constexpr SkipManyParser(const SkipManyParser &) = default;
   constexpr SkipManyParser(PA parser) : parser_{parser} {}
   std::optional<Success> Parse(ParseState &state) const {
     for (auto at{state.GetLocation()};
          parser_.Parse(state) && state.GetLocation() > at;
          at = state.GetLocation()) {
     }
     return Success{};
   }
 
 private:
   const BacktrackingParser<PA> parser_;
 };
 
 template <typename PA> inline constexpr auto skipMany(PA parser) {
   return SkipManyParser<PA>{parser};
 }
 
 // If x is a parser, skipManyFast(x) is equivalent to skipMany(x).
 // The parser x must always advance on success and never invalidate the
 // state on failure.
 template <typename PA> class SkipManyFastParser {
 public:
   using resultType = Success;
   constexpr SkipManyFastParser(const SkipManyFastParser &) = default;
   constexpr SkipManyFastParser(PA parser) : parser_{parser} {}
   std::optional<Success> Parse(ParseState &state) const {
     while (parser_.Parse(state)) {
     }
     return Success{};
   }
 
 private:
   const PA parser_;
 };
 
 template <typename PA> inline constexpr auto skipManyFast(PA parser) {
   return SkipManyFastParser<PA>{parser};
 }
 
 // If x is a parser returning some type A, then maybe(x) returns a
 // parser that returns std::optional<A>, always succeeding.
 template <typename PA> class MaybeParser {
   using paType = typename PA::resultType;
 
 public:
   using resultType = std::optional<paType>;
   constexpr MaybeParser(const MaybeParser &) = default;
   constexpr MaybeParser(PA parser) : parser_{parser} {}
   std::optional<resultType> Parse(ParseState &state) const {
     if (resultType result{parser_.Parse(state)}) {
       // permit optional<optional<...>>
       return {std::move(result)};
     }
     return resultType{};
   }
 
 private:
   const BacktrackingParser<PA> parser_;
 };
 
 template <typename PA> inline constexpr auto maybe(PA parser) {
   return MaybeParser<PA>{parser};
 }
 
 // If x is a parser, then defaulted(x) returns a parser that always
 // succeeds.  When x succeeds, its result is that of x; otherwise, its
 // result is a default-constructed value of x's result type.
 template <typename PA> class DefaultedParser {
 public:
   using resultType = typename PA::resultType;
   constexpr DefaultedParser(const DefaultedParser &) = default;
   constexpr DefaultedParser(PA p) : parser_{p} {}
   std::optional<resultType> Parse(ParseState &state) const {
     std::optional<std::optional<resultType>> ax{maybe(parser_).Parse(state)};
     if (ax.value()) { // maybe() always succeeds
       return std::move(*ax);
     }
     return resultType{};
   }
 
 private:
   const BacktrackingParser<PA> parser_;
 };
 
 template <typename PA> inline constexpr auto defaulted(PA p) {
   return DefaultedParser<PA>(p);
 }
 
 // If a is a parser, and f is a function mapping an rvalue of a's result type
 // to some other type T, then applyFunction(f, a) returns a parser that succeeds
 // iff a does, and whose result value ax has been passed through the function;
 // the final result is that returned by the call f(std::move(ax)).
 //
 // Function application is generalized to functions with more than one
 // argument with applyFunction(f, a, b, ...) succeeding if all of the parsers
 // a, b, &c. do so, and the result is the value of applying f to their
 // results.
 //
 // applyLambda(f, ...) is the same concept extended to std::function<> functors.
 // It is not constexpr.
 //
 // Member function application is supported by applyMem(f, a).  If the
 // parser a succeeds and returns some value ax, the result is that returned
 // by ax.f().  Additional parser arguments can be specified to supply their
 // results to the member function call, so applyMem(f, a, b) succeeds if
 // both a and b do so and returns the result of calling ax.f(std::move(bx)).
 
 // Runs a sequence of parsers until one fails or all have succeeded.
 // Collects their results in a std::tuple<std::optional<>...>.
 template <typename... PARSER>
 using ApplyArgs = std::tuple<std::optional<typename PARSER::resultType>...>;
 
 template <typename... PARSER, std::size_t... J>
 inline bool ApplyHelperArgs(const std::tuple<PARSER...> &parsers,
     ApplyArgs<PARSER...> &args, ParseState &state, std::index_sequence<J...>) {
   return (... &&
       (std::get<J>(args) = std::get<J>(parsers).Parse(state),
           std::get<J>(args).has_value()));
 }
 
 // Applies a function to the arguments collected by ApplyHelperArgs.
 template <typename RESULT, typename... PARSER>
 using ApplicableFunctionPointer = RESULT (*)(typename PARSER::resultType &&...);
 template <typename RESULT, typename... PARSER>
 using ApplicableFunctionObject =
     const std::function<RESULT(typename PARSER::resultType &&...)> &;
 
 template <template <typename...> class FUNCTION, typename RESULT,
     typename... PARSER, std::size_t... J>
 inline RESULT ApplyHelperFunction(FUNCTION<RESULT, PARSER...> f,
     ApplyArgs<PARSER...> &&args, std::index_sequence<J...>) {
   return f(std::move(*std::get<J>(args))...);
 }
 
 template <template <typename...> class FUNCTION, typename RESULT,
     typename... PARSER>
 class ApplyFunction {
   using funcType = FUNCTION<RESULT, PARSER...>;
 
 public:
   using resultType = RESULT;
   constexpr ApplyFunction(const ApplyFunction &) = default;
   constexpr ApplyFunction(funcType f, PARSER... p)
       : function_{f}, parsers_{p...} {}
   std::optional<resultType> Parse(ParseState &state) const {
     ApplyArgs<PARSER...> results;
     using Sequence = std::index_sequence_for<PARSER...>;
     if (ApplyHelperArgs(parsers_, results, state, Sequence{})) {
       return ApplyHelperFunction<FUNCTION, RESULT, PARSER...>(
           function_, std::move(results), Sequence{});
     } else {
       return std::nullopt;
     }
   }
 
 private:
   const funcType function_;
   const std::tuple<PARSER...> parsers_;
 };
 
 template <typename RESULT, typename... PARSER>
 inline constexpr auto applyFunction(
-    ApplicableFunctionPointer<RESULT, PARSER...> f, const PARSER &... parser) {
+    ApplicableFunctionPointer<RESULT, PARSER...> f, const PARSER &...parser) {
   return ApplyFunction<ApplicableFunctionPointer, RESULT, PARSER...>{
       f, parser...};
 }
 
 template <typename RESULT, typename... PARSER>
 inline /* not constexpr */ auto applyLambda(
-    ApplicableFunctionObject<RESULT, PARSER...> f, const PARSER &... parser) {
+    ApplicableFunctionObject<RESULT, PARSER...> f, const PARSER &...parser) {
   return ApplyFunction<ApplicableFunctionObject, RESULT, PARSER...>{
       f, parser...};
 }
 
 // Member function application
 template <typename OBJPARSER, typename... PARSER> class AMFPHelper {
   using resultType = typename OBJPARSER::resultType;
 
 public:
   using type = void (resultType::*)(typename PARSER::resultType &&...);
 };
 template <typename OBJPARSER, typename... PARSER>
 using ApplicableMemberFunctionPointer =
     typename AMFPHelper<OBJPARSER, PARSER...>::type;
 
 template <typename OBJPARSER, typename... PARSER, std::size_t... J>
 inline auto ApplyHelperMember(
     ApplicableMemberFunctionPointer<OBJPARSER, PARSER...> mfp,
     ApplyArgs<OBJPARSER, PARSER...> &&args, std::index_sequence<J...>) ->
     typename OBJPARSER::resultType {
   ((*std::get<0>(args)).*mfp)(std::move(*std::get<J + 1>(args))...);
   return std::get<0>(std::move(args));
 }
 
 template <typename OBJPARSER, typename... PARSER> class ApplyMemberFunction {
   using funcType = ApplicableMemberFunctionPointer<OBJPARSER, PARSER...>;
 
 public:
   using resultType = typename OBJPARSER::resultType;
   constexpr ApplyMemberFunction(const ApplyMemberFunction &) = default;
   constexpr ApplyMemberFunction(funcType f, OBJPARSER o, PARSER... p)
       : function_{f}, parsers_{o, p...} {}
   std::optional<resultType> Parse(ParseState &state) const {
     ApplyArgs<OBJPARSER, PARSER...> results;
     using Sequence1 = std::index_sequence_for<OBJPARSER, PARSER...>;
     using Sequence2 = std::index_sequence_for<PARSER...>;
     if (ApplyHelperArgs(parsers_, results, state, Sequence1{})) {
       return ApplyHelperMember<OBJPARSER, PARSER...>(
           function_, std::move(results), Sequence2{});
     } else {
       return std::nullopt;
     }
   }
 
 private:
   const funcType function_;
   const std::tuple<OBJPARSER, PARSER...> parsers_;
 };
 
 template <typename OBJPARSER, typename... PARSER>
 inline constexpr auto applyMem(
     ApplicableMemberFunctionPointer<OBJPARSER, PARSER...> mfp,
     const OBJPARSER &objParser, PARSER... parser) {
   return ApplyMemberFunction<OBJPARSER, PARSER...>{mfp, objParser, parser...};
 }
 
 // As is done with function application via applyFunction() above, class
 // instance construction can also be based upon the results of successful
 // parses.  For some type T and zero or more parsers a, b, &c., the call
 // construct<T>(a, b, ...) returns a parser that succeeds if all of
 // its argument parsers do so in succession, and whose result is an
 // instance of T constructed upon the values they returned.
 // With a single argument that is a parser with no usable value,
 // construct<T>(p) invokes T's default nullary constructor (T(){}).
 // (This means that "construct<T>(Foo >> Bar >> ok)" is functionally
 // equivalent to "Foo >> Bar >> construct<T>()", but I'd like to hold open
 // the opportunity to make construct<> capture source provenance all of the
 // time, and the first form will then lead to better error positioning.)
 
 template <typename RESULT, typename... PARSER, std::size_t... J>
 inline RESULT ApplyHelperConstructor(
     ApplyArgs<PARSER...> &&args, std::index_sequence<J...>) {
   return RESULT{std::move(*std::get<J>(args))...};
 }
 
 template <typename RESULT, typename... PARSER> class ApplyConstructor {
 public:
   using resultType = RESULT;
   constexpr ApplyConstructor(const ApplyConstructor &) = default;
   constexpr explicit ApplyConstructor(PARSER... p) : parsers_{p...} {}
   std::optional<resultType> Parse(ParseState &state) const {
     if constexpr (sizeof...(PARSER) == 0) {
       return RESULT{};
     } else {
       if constexpr (sizeof...(PARSER) == 1) {
         if constexpr (std::is_same_v<Success, typename PARSER::resultType...>) {
           if (std::get<0>(parsers_).Parse(state)) {
             return RESULT{};
           }
         } else if (auto arg{std::get<0>(parsers_).Parse(state)}) {
           return RESULT{std::move(*arg)};
         }
       } else {
         ApplyArgs<PARSER...> results;
         using Sequence = std::index_sequence_for<PARSER...>;
         if (ApplyHelperArgs(parsers_, results, state, Sequence{})) {
           return ApplyHelperConstructor<RESULT, PARSER...>(
               std::move(results), Sequence{});
         }
       }
       return std::nullopt;
     }
   }
 
 private:
   const std::tuple<PARSER...> parsers_;
 };
 
 template <typename RESULT, typename... PARSER>
 inline constexpr auto construct(PARSER... p) {
   return ApplyConstructor<RESULT, PARSER...>{p...};
 }
 
 // For a parser p, indirect(p) returns a parser that builds an indirect
 // reference to p's return type.
 template <typename PA> inline constexpr auto indirect(PA p) {
   return construct<common::Indirection<typename PA::resultType>>(p);
 }
 
 // If a and b are parsers, then nonemptySeparated(a, b) returns a parser
 // that succeeds if a does.  If a succeeds, it then applies many(b >> a).
 // The result is the list of the values returned from all of the applications
 // of a.
 template <typename T>
 common::IfNoLvalue<std::list<T>, T> prepend(T &&head, std::list<T> &&rest) {
   rest.push_front(std::move(head));
   return std::move(rest);
 }
 
 template <typename PA, typename PB> class NonemptySeparated {
 private:
   using paType = typename PA::resultType;
 
 public:
   using resultType = std::list<paType>;
   constexpr NonemptySeparated(const NonemptySeparated &) = default;
   constexpr NonemptySeparated(PA p, PB sep) : parser_{p}, separator_{sep} {}
   std::optional<resultType> Parse(ParseState &state) const {
     return applyFunction(prepend<paType>, parser_, many(separator_ >> parser_))
         .Parse(state);
   }
 
 private:
   const PA parser_;
   const PB separator_;
 };
 
 template <typename PA, typename PB>
 inline constexpr auto nonemptySeparated(PA p, PB sep) {
   return NonemptySeparated<PA, PB>{p, sep};
 }
 
 // ok is a parser that always succeeds.  It is useful when a parser
 // must discard its result in order to be compatible in type with other
 // parsers in an alternative, e.g. "x >> ok || y >> ok" is type-safe even
 // when x and y have distinct result types.
 constexpr struct OkParser {
   using resultType = Success;
   constexpr OkParser() {}
   static constexpr std::optional<Success> Parse(ParseState &) {
     return Success{};
   }
 } ok;
 
 // A variant of recovery() above for convenience.
 template <typename PA, typename PB>
 inline constexpr auto localRecovery(MessageFixedText msg, PA pa, PB pb) {
   return recovery(withMessage(msg, pa), pb >> pure<typename PA::resultType>());
 }
 
 // nextCh is a parser that succeeds if the parsing state is not
 // at the end of its input, returning the next character location and
 // advancing the parse when it does so.
 struct NextCh {
   using resultType = const char *;
   constexpr NextCh() {}
   std::optional<const char *> Parse(ParseState &state) const {
     if (std::optional<const char *> result{state.GetNextChar()}) {
       return result;
     }
     state.Say("end of file"_err_en_US);
     return std::nullopt;
   }
 };
 
 constexpr NextCh nextCh;
 
 // If a is a parser for some nonstandard language feature LF, extension<LF>(a)
 // is a parser that optionally enabled, sets a strict conformance violation
 // flag, and may emit a warning message, if those are enabled.
 template <LanguageFeature LF, typename PA> class NonstandardParser {
 public:
   using resultType = typename PA::resultType;
   constexpr NonstandardParser(const NonstandardParser &) = default;
   constexpr NonstandardParser(PA parser) : parser_{parser} {}
   std::optional<resultType> Parse(ParseState &state) const {
     if (UserState * ustate{state.userState()}) {
       if (!ustate->features().IsEnabled(LF)) {
         return std::nullopt;
       }
     }
     auto at{state.GetLocation()};
     auto result{parser_.Parse(state)};
     if (result) {
       state.Nonstandard(
           CharBlock{at, state.GetLocation()}, LF, "nonstandard usage"_en_US);
     }
     return result;
   }
 
 private:
   const PA parser_;
 };
 
 template <LanguageFeature LF, typename PA>
 inline constexpr auto extension(PA parser) {
   return NonstandardParser<LF, PA>(parser);
 }
 
 // If a is a parser for some deprecated or deleted language feature LF,
 // deprecated<LF>(a) is a parser that is optionally enabled, sets a strict
 // conformance violation flag, and may emit a warning message, if enabled.
 template <LanguageFeature LF, typename PA> class DeprecatedParser {
 public:
   using resultType = typename PA::resultType;
   constexpr DeprecatedParser(const DeprecatedParser &) = default;
   constexpr DeprecatedParser(PA parser) : parser_{parser} {}
   std::optional<resultType> Parse(ParseState &state) const {
     if (UserState * ustate{state.userState()}) {
       if (!ustate->features().IsEnabled(LF)) {
         return std::nullopt;
       }
     }
     auto at{state.GetLocation()};
     auto result{parser_.Parse(state)};
     if (result) {
       state.Nonstandard(
           CharBlock{at, state.GetLocation()}, LF, "deprecated usage"_en_US);
     }
     return result;
   }
 
 private:
   const PA parser_;
 };
 
 template <LanguageFeature LF, typename PA>
 inline constexpr auto deprecated(PA parser) {
   return DeprecatedParser<LF, PA>(parser);
 }
 
 // Parsing objects with "source" members.
 template <typename PA> class SourcedParser {
 public:
   using resultType = typename PA::resultType;
   constexpr SourcedParser(const SourcedParser &) = default;
   constexpr SourcedParser(PA parser) : parser_{parser} {}
   std::optional<resultType> Parse(ParseState &state) const {
     const char *start{state.GetLocation()};
     auto result{parser_.Parse(state)};
     if (result) {
       const char *end{state.GetLocation()};
       for (; start < end && start[0] == ' '; ++start) {
       }
       for (; start < end && end[-1] == ' '; --end) {
       }
       result->source = CharBlock{start, end};
     }
     return result;
   }
 
 private:
   const PA parser_;
 };
 
 template <typename PA> inline constexpr auto sourced(PA parser) {
   return SourcedParser<PA>{parser};
 }
 } // namespace Fortran::parser
 #endif // FORTRAN_PARSER_BASIC_PARSERS_H_
diff --git a/flang/lib/Parser/prescan.h b/flang/lib/Parser/prescan.h
index 6e492a73597b..c4fdeae6e15e 100644
--- a/flang/lib/Parser/prescan.h
+++ b/flang/lib/Parser/prescan.h
@@ -1,232 +1,232 @@
 //===-- lib/Parser/prescan.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_PRESCAN_H_
 #define FORTRAN_PARSER_PRESCAN_H_
 
 // Defines a fast Fortran source prescanning phase that implements some
 // character-level features of the language that can be inefficient to
 // support directly in a backtracking parser.  This phase handles Fortran
 // line continuation, comment removal, card image margins, padding out
 // fixed form character literals on truncated card images, file
 // inclusion, and driving the Fortran source preprocessor.
 
 #include "token-sequence.h"
 #include "flang/Common/Fortran-features.h"
 #include "flang/Parser/characters.h"
 #include "flang/Parser/message.h"
 #include "flang/Parser/provenance.h"
 #include <bitset>
 #include <optional>
 #include <string>
 #include <unordered_set>
 
 namespace Fortran::parser {
 
 class Messages;
 class Preprocessor;
 
 class Prescanner {
 public:
   Prescanner(Messages &, CookedSource &, Preprocessor &,
       common::LanguageFeatureControl);
   Prescanner(const Prescanner &);
 
   Messages &messages() const { return messages_; }
 
   Prescanner &set_fixedForm(bool yes) {
     inFixedForm_ = yes;
     return *this;
   }
   Prescanner &set_encoding(Encoding code) {
     encoding_ = code;
     return *this;
   }
   Prescanner &set_fixedFormColumnLimit(int limit) {
     fixedFormColumnLimit_ = limit;
     return *this;
   }
 
   Prescanner &AddCompilerDirectiveSentinel(const std::string &);
 
   void Prescan(ProvenanceRange);
   void Statement();
   void NextLine();
 
   // Callbacks for use by Preprocessor.
   bool IsAtEnd() const { return nextLine_ >= limit_; }
   bool IsNextLinePreprocessorDirective() const;
   TokenSequence TokenizePreprocessorDirective();
   Provenance GetCurrentProvenance() const { return GetProvenance(at_); }
 
-  template <typename... A> Message &Say(A &&... a) {
+  template <typename... A> Message &Say(A &&...a) {
     Message &m{messages_.Say(std::forward<A>(a)...)};
     std::optional<ProvenanceRange> range{m.GetProvenanceRange(cooked_)};
     CHECK(!range || cooked_.IsValid(*range));
     return m;
   }
 
 private:
   struct LineClassification {
     enum class Kind {
       Comment,
       ConditionalCompilationDirective,
       IncludeDirective, // #include
       DefinitionDirective, // #define & #undef
       PreprocessorDirective,
       IncludeLine, // Fortran INCLUDE
       CompilerDirective,
       Source
     };
     LineClassification(Kind k, std::size_t po = 0, const char *s = nullptr)
         : kind{k}, payloadOffset{po}, sentinel{s} {}
     LineClassification(LineClassification &&) = default;
     Kind kind;
     std::size_t payloadOffset; // byte offset of content
     const char *sentinel; // if it's a compiler directive
   };
 
   void BeginSourceLine(const char *at) {
     at_ = at;
     column_ = 1;
     tabInCurrentLine_ = false;
     slashInCurrentLine_ = false;
     preventHollerith_ = false;
     delimiterNesting_ = 0;
   }
 
   void BeginSourceLineAndAdvance() {
     BeginSourceLine(nextLine_);
     NextLine();
   }
 
   Provenance GetProvenance(const char *sourceChar) const {
     return startProvenance_ + (sourceChar - start_);
   }
 
   ProvenanceRange GetProvenanceRange(
       const char *first, const char *afterLast) const {
     std::size_t bytes = afterLast - first;
     return {startProvenance_ + (first - start_), bytes};
   }
 
   void EmitChar(TokenSequence &tokens, char ch) {
     tokens.PutNextTokenChar(ch, GetCurrentProvenance());
   }
 
   void EmitInsertedChar(TokenSequence &tokens, char ch) {
     Provenance provenance{cooked_.allSources().CompilerInsertionProvenance(ch)};
     tokens.PutNextTokenChar(ch, provenance);
   }
 
   char EmitCharAndAdvance(TokenSequence &tokens, char ch) {
     EmitChar(tokens, ch);
     NextChar();
     return *at_;
   }
 
   bool InCompilerDirective() const { return directiveSentinel_ != nullptr; }
   bool InFixedFormSource() const {
     return inFixedForm_ && !inPreprocessorDirective_ && !InCompilerDirective();
   }
 
   bool IsCComment(const char *p) const {
     return p[0] == '/' && p[1] == '*' &&
         (inPreprocessorDirective_ ||
             (!inCharLiteral_ &&
                 features_.IsEnabled(
                     common::LanguageFeature::ClassicCComments)));
   }
 
   void LabelField(TokenSequence &, int outCol = 1);
   void SkipToEndOfLine();
   bool MustSkipToEndOfLine() const;
   void NextChar();
   void SkipToNextSignificantCharacter();
   void SkipCComments();
   void SkipSpaces();
   static const char *SkipWhiteSpace(const char *);
   const char *SkipWhiteSpaceAndCComments(const char *) const;
   const char *SkipCComment(const char *) const;
   bool NextToken(TokenSequence &);
   bool ExponentAndKind(TokenSequence &);
   void QuotedCharacterLiteral(TokenSequence &, const char *start);
   void Hollerith(TokenSequence &, int count, const char *start);
   bool PadOutCharacterLiteral(TokenSequence &);
   bool SkipCommentLine(bool afterAmpersand);
   bool IsFixedFormCommentLine(const char *) const;
   const char *IsFreeFormComment(const char *) const;
   std::optional<std::size_t> IsIncludeLine(const char *) const;
   void FortranInclude(const char *quote);
   const char *IsPreprocessorDirectiveLine(const char *) const;
   const char *FixedFormContinuationLine(bool mightNeedSpace);
   const char *FreeFormContinuationLine(bool ampersand);
   bool IsImplicitContinuation() const;
   bool FixedFormContinuation(bool mightNeedSpace);
   bool FreeFormContinuation();
   bool Continuation(bool mightNeedFixedFormSpace);
   std::optional<LineClassification> IsFixedFormCompilerDirectiveLine(
       const char *) const;
   std::optional<LineClassification> IsFreeFormCompilerDirectiveLine(
       const char *) const;
   const char *IsCompilerDirectiveSentinel(const char *) const;
   LineClassification ClassifyLine(const char *) const;
   void SourceFormChange(std::string &&);
 
   Messages &messages_;
   CookedSource &cooked_;
   Preprocessor &preprocessor_;
   common::LanguageFeatureControl features_;
   bool inFixedForm_{false};
   int fixedFormColumnLimit_{72};
   Encoding encoding_{Encoding::UTF_8};
   int delimiterNesting_{0};
   int prescannerNesting_{0};
 
   Provenance startProvenance_;
   const char *start_{nullptr}; // beginning of current source file content
   const char *limit_{nullptr}; // first address after end of current source
   const char *nextLine_{nullptr}; // next line to process; <= limit_
   const char *directiveSentinel_{nullptr}; // current compiler directive
 
   // This data members are state for processing the source line containing
   // "at_", which goes to up to the newline character before "nextLine_".
   const char *at_{nullptr}; // next character to process; < nextLine_
   int column_{1}; // card image column position of next character
   bool tabInCurrentLine_{false};
   bool slashInCurrentLine_{false};
   bool preventHollerith_{false};
   bool inCharLiteral_{false};
   bool inPreprocessorDirective_{false};
 
   // In some edge cases of compiler directive continuation lines, it
   // is necessary to treat the line break as a space character by
   // setting this flag, which is cleared by EmitChar().
   bool insertASpace_{false};
 
   // When a free form continuation marker (&) appears at the end of a line
   // before a INCLUDE or #include, we delete it and omit the newline, so
   // that the first line of the included file is truly a continuation of
   // the line before.  Also used when the & appears at the end of the last
   // line in an include file.
   bool omitNewline_{false};
   bool skipLeadingAmpersand_{false};
 
   const Provenance spaceProvenance_{
       cooked_.allSources().CompilerInsertionProvenance(' ')};
   const Provenance backslashProvenance_{
       cooked_.allSources().CompilerInsertionProvenance('\\')};
 
   // To avoid probing the set of active compiler directive sentinel strings
   // on every comment line, they're checked first with a cheap Bloom filter.
   static const int prime1{1019}, prime2{1021};
   std::bitset<prime2> compilerDirectiveBloomFilter_; // 128 bytes
   std::unordered_set<std::string> compilerDirectiveSentinels_;
 };
 } // namespace Fortran::parser
 #endif // FORTRAN_PARSER_PRESCAN_H_
diff --git a/flang/lib/Semantics/assignment.cpp b/flang/lib/Semantics/assignment.cpp
index ab8f5e4fdf56..0b765c72fdd7 100644
--- a/flang/lib/Semantics/assignment.cpp
+++ b/flang/lib/Semantics/assignment.cpp
@@ -1,296 +1,296 @@
 //===-- lib/Semantics/assignment.cpp --------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "assignment.h"
 #include "pointer-assignment.h"
 #include "flang/Common/idioms.h"
 #include "flang/Common/restorer.h"
 #include "flang/Evaluate/characteristics.h"
 #include "flang/Evaluate/expression.h"
 #include "flang/Evaluate/fold.h"
 #include "flang/Evaluate/tools.h"
 #include "flang/Parser/message.h"
 #include "flang/Parser/parse-tree-visitor.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
 #include <optional>
 #include <set>
 #include <string>
 #include <type_traits>
 
 using namespace Fortran::parser::literals;
 
 namespace Fortran::semantics {
 
 class AssignmentContext {
 public:
   explicit AssignmentContext(SemanticsContext &context) : context_{context} {}
   AssignmentContext(AssignmentContext &&) = default;
   AssignmentContext(const AssignmentContext &) = delete;
   bool operator==(const AssignmentContext &x) const { return this == &x; }
 
   template <typename A> void PushWhereContext(const A &);
   void PopWhereContext();
   void Analyze(const parser::AssignmentStmt &);
   void Analyze(const parser::PointerAssignmentStmt &);
   void Analyze(const parser::ConcurrentControl &);
 
 private:
   bool CheckForPureContext(const SomeExpr &lhs, const SomeExpr &rhs,
       parser::CharBlock rhsSource, bool isPointerAssignment);
   void CheckShape(parser::CharBlock, const SomeExpr *);
   template <typename... A>
-  parser::Message *Say(parser::CharBlock at, A &&... args) {
+  parser::Message *Say(parser::CharBlock at, A &&...args) {
     return &context_.Say(at, std::forward<A>(args)...);
   }
   evaluate::FoldingContext &foldingContext() {
     return context_.foldingContext();
   }
 
   SemanticsContext &context_;
   int whereDepth_{0}; // number of WHEREs currently nested in
   // shape of masks in LHS of assignments in current WHERE:
   std::vector<std::optional<std::int64_t>> whereExtents_;
 };
 
 void AssignmentContext::Analyze(const parser::AssignmentStmt &stmt) {
   if (const evaluate::Assignment * assignment{GetAssignment(stmt)}) {
     const SomeExpr &lhs{assignment->lhs};
     const SomeExpr &rhs{assignment->rhs};
     auto lhsLoc{std::get<parser::Variable>(stmt.t).GetSource()};
     auto rhsLoc{std::get<parser::Expr>(stmt.t).source};
     auto shape{evaluate::GetShape(foldingContext(), lhs)};
     if (shape && !shape->empty() && !shape->back().has_value()) { // C1014
       Say(lhsLoc,
           "Left-hand side of assignment may not be a whole assumed-size array"_err_en_US);
     }
     if (CheckForPureContext(lhs, rhs, rhsLoc, false)) {
       const Scope &scope{context_.FindScope(lhsLoc)};
       if (auto whyNot{WhyNotModifiable(lhsLoc, lhs, scope, true)}) {
         if (auto *msg{Say(lhsLoc,
                 "Left-hand side of assignment is not modifiable"_err_en_US)}) { // C1158
           msg->Attach(*whyNot);
         }
       }
     }
     if (whereDepth_ > 0) {
       CheckShape(lhsLoc, &lhs);
     }
   }
 }
 
 void AssignmentContext::Analyze(const parser::PointerAssignmentStmt &stmt) {
   CHECK(whereDepth_ == 0);
   if (const evaluate::Assignment * assignment{GetAssignment(stmt)}) {
     const SomeExpr &lhs{assignment->lhs};
     const SomeExpr &rhs{assignment->rhs};
     CheckForPureContext(lhs, rhs, std::get<parser::Expr>(stmt.t).source, true);
     auto restorer{
         foldingContext().messages().SetLocation(context_.location().value())};
     CheckPointerAssignment(foldingContext(), *assignment);
   }
 }
 
 // C1594 checks
 static bool IsPointerDummyOfPureFunction(const Symbol &x) {
   return IsPointerDummy(x) && FindPureProcedureContaining(x.owner()) &&
       x.owner().symbol() && IsFunction(*x.owner().symbol());
 }
 
 static const char *WhyBaseObjectIsSuspicious(
     const Symbol &x, const Scope &scope) {
   // See C1594, first paragraph.  These conditions enable checks on both
   // left-hand and right-hand sides in various circumstances.
   if (IsHostAssociated(x, scope)) {
     return "host-associated";
   } else if (IsUseAssociated(x, scope)) {
     return "USE-associated";
   } else if (IsPointerDummyOfPureFunction(x)) {
     return "a POINTER dummy argument of a pure function";
   } else if (IsIntentIn(x)) {
     return "an INTENT(IN) dummy argument";
   } else if (FindCommonBlockContaining(x)) {
     return "in a COMMON block";
   } else {
     return nullptr;
   }
 }
 
 // Checks C1594(1,2); false if check fails
 bool CheckDefinabilityInPureScope(parser::ContextualMessages &messages,
     const Symbol &lhs, const Scope &context, const Scope &pure) {
   if (pure.symbol()) {
     if (const char *why{WhyBaseObjectIsSuspicious(lhs, context)}) {
       evaluate::SayWithDeclaration(messages, lhs,
           "Pure subprogram '%s' may not define '%s' because it is %s"_err_en_US,
           pure.symbol()->name(), lhs.name(), why);
       return false;
     }
   }
   return true;
 }
 
 static std::optional<std::string> GetPointerComponentDesignatorName(
     const SomeExpr &expr) {
   if (const auto *derived{
           evaluate::GetDerivedTypeSpec(evaluate::DynamicType::From(expr))}) {
     UltimateComponentIterator ultimates{*derived};
     if (auto pointer{
             std::find_if(ultimates.begin(), ultimates.end(), IsPointer)}) {
       return pointer.BuildResultDesignatorName();
     }
   }
   return std::nullopt;
 }
 
 // Checks C1594(5,6); false if check fails
 bool CheckCopyabilityInPureScope(parser::ContextualMessages &messages,
     const SomeExpr &expr, const Scope &scope) {
   if (const Symbol * base{GetFirstSymbol(expr)}) {
     if (const char *why{WhyBaseObjectIsSuspicious(*base, scope)}) {
       if (auto pointer{GetPointerComponentDesignatorName(expr)}) {
         evaluate::SayWithDeclaration(messages, *base,
             "A pure subprogram may not copy the value of '%s' because it is %s"
             " and has the POINTER component '%s'"_err_en_US,
             base->name(), why, *pointer);
         return false;
       }
     }
   }
   return true;
 }
 
 bool AssignmentContext::CheckForPureContext(const SomeExpr &lhs,
     const SomeExpr &rhs, parser::CharBlock source, bool isPointerAssignment) {
   const Scope &scope{context_.FindScope(source)};
   if (const Scope * pure{FindPureProcedureContaining(scope)}) {
     parser::ContextualMessages messages{
         context_.location().value(), &context_.messages()};
     if (evaluate::ExtractCoarrayRef(lhs)) {
       messages.Say(
           "A pure subprogram may not define a coindexed object"_err_en_US);
     } else if (const Symbol * base{GetFirstSymbol(lhs)}) {
       if (const auto *assoc{base->detailsIf<AssocEntityDetails>()}) {
         auto dataRef{ExtractDataRef(assoc->expr(), true)};
         // ASSOCIATE(a=>x) -- check x, not a, for "a=..."
         base = dataRef ? &dataRef->GetFirstSymbol() : nullptr;
       }
       if (base &&
           !CheckDefinabilityInPureScope(messages, *base, scope, *pure)) {
         return false;
       }
     }
     if (isPointerAssignment) {
       if (const Symbol * base{GetFirstSymbol(rhs)}) {
         if (const char *why{
                 WhyBaseObjectIsSuspicious(*base, scope)}) { // C1594(3)
           evaluate::SayWithDeclaration(messages, *base,
               "A pure subprogram may not use '%s' as the target of pointer assignment because it is %s"_err_en_US,
               base->name(), why);
           return false;
         }
       }
     } else if (auto type{evaluate::DynamicType::From(lhs)}) {
       // C1596 checks for polymorphic deallocation in a pure subprogram
       // due to automatic reallocation on assignment
       if (type->IsPolymorphic()) {
         context_.Say(
             "Deallocation of polymorphic object is not permitted in a pure subprogram"_err_en_US);
         return false;
       }
       if (const DerivedTypeSpec * derived{GetDerivedTypeSpec(type)}) {
         if (auto bad{FindPolymorphicAllocatableNonCoarrayUltimateComponent(
                 *derived)}) {
           evaluate::SayWithDeclaration(messages, *bad,
               "Deallocation of polymorphic non-coarray component '%s' is not permitted in a pure subprogram"_err_en_US,
               bad.BuildResultDesignatorName());
           return false;
         } else {
           return CheckCopyabilityInPureScope(messages, rhs, scope);
         }
       }
     }
   }
   return true;
 }
 
 // 10.2.3.1(2) The masks and LHS of assignments must all have the same shape
 void AssignmentContext::CheckShape(parser::CharBlock at, const SomeExpr *expr) {
   if (auto shape{evaluate::GetShape(foldingContext(), expr)}) {
     std::size_t size{shape->size()};
     if (whereDepth_ == 0) {
       whereExtents_.resize(size);
     } else if (whereExtents_.size() != size) {
       Say(at,
           "Must have rank %zd to match prior mask or assignment of"
           " WHERE construct"_err_en_US,
           whereExtents_.size());
       return;
     }
     for (std::size_t i{0}; i < size; ++i) {
       if (std::optional<std::int64_t> extent{evaluate::ToInt64((*shape)[i])}) {
         if (!whereExtents_[i]) {
           whereExtents_[i] = *extent;
         } else if (*whereExtents_[i] != *extent) {
           Say(at,
               "Dimension %d must have extent %jd to match prior mask or"
               " assignment of WHERE construct"_err_en_US,
               i + 1, *whereExtents_[i]);
         }
       }
     }
   }
 }
 
 template <typename A> void AssignmentContext::PushWhereContext(const A &x) {
   const auto &expr{std::get<parser::LogicalExpr>(x.t)};
   CheckShape(expr.thing.value().source, GetExpr(expr));
   ++whereDepth_;
 }
 
 void AssignmentContext::PopWhereContext() {
   --whereDepth_;
   if (whereDepth_ == 0) {
     whereExtents_.clear();
   }
 }
 
 AssignmentChecker::~AssignmentChecker() {}
 
 AssignmentChecker::AssignmentChecker(SemanticsContext &context)
     : context_{new AssignmentContext{context}} {}
 void AssignmentChecker::Enter(const parser::AssignmentStmt &x) {
   context_.value().Analyze(x);
 }
 void AssignmentChecker::Enter(const parser::PointerAssignmentStmt &x) {
   context_.value().Analyze(x);
 }
 void AssignmentChecker::Enter(const parser::WhereStmt &x) {
   context_.value().PushWhereContext(x);
 }
 void AssignmentChecker::Leave(const parser::WhereStmt &) {
   context_.value().PopWhereContext();
 }
 void AssignmentChecker::Enter(const parser::WhereConstructStmt &x) {
   context_.value().PushWhereContext(x);
 }
 void AssignmentChecker::Leave(const parser::EndWhereStmt &) {
   context_.value().PopWhereContext();
 }
 void AssignmentChecker::Enter(const parser::MaskedElsewhereStmt &x) {
   context_.value().PushWhereContext(x);
 }
 void AssignmentChecker::Leave(const parser::MaskedElsewhereStmt &) {
   context_.value().PopWhereContext();
 }
 
 } // namespace Fortran::semantics
 template class Fortran::common::Indirection<
     Fortran::semantics::AssignmentContext>;
diff --git a/flang/lib/Semantics/check-declarations.cpp b/flang/lib/Semantics/check-declarations.cpp
index a1f5be231fd9..4e91235938e6 100644
--- a/flang/lib/Semantics/check-declarations.cpp
+++ b/flang/lib/Semantics/check-declarations.cpp
@@ -1,1560 +1,1560 @@
 //===-- lib/Semantics/check-declarations.cpp ------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // Static declaration checking
 
 #include "check-declarations.h"
 #include "flang/Evaluate/check-expression.h"
 #include "flang/Evaluate/fold.h"
 #include "flang/Evaluate/tools.h"
 #include "flang/Semantics/scope.h"
 #include "flang/Semantics/semantics.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
 #include "flang/Semantics/type.h"
 #include <algorithm>
 
 namespace Fortran::semantics {
 
 using evaluate::characteristics::DummyArgument;
 using evaluate::characteristics::DummyDataObject;
 using evaluate::characteristics::DummyProcedure;
 using evaluate::characteristics::FunctionResult;
 using evaluate::characteristics::Procedure;
 
 class CheckHelper {
 public:
   explicit CheckHelper(SemanticsContext &c) : context_{c} {}
 
   void Check() { Check(context_.globalScope()); }
   void Check(const ParamValue &, bool canBeAssumed);
   void Check(const Bound &bound) { CheckSpecExpr(bound.GetExplicit()); }
   void Check(const ShapeSpec &spec) {
     Check(spec.lbound());
     Check(spec.ubound());
   }
   void Check(const ArraySpec &);
   void Check(const DeclTypeSpec &, bool canHaveAssumedTypeParameters);
   void Check(const Symbol &);
   void Check(const Scope &);
 
 private:
   template <typename A> void CheckSpecExpr(const A &x) {
     evaluate::CheckSpecificationExpr(
         x, messages_, DEREF(scope_), context_.intrinsics());
   }
   void CheckValue(const Symbol &, const DerivedTypeSpec *);
   void CheckVolatile(
       const Symbol &, bool isAssociated, const DerivedTypeSpec *);
   void CheckPointer(const Symbol &);
   void CheckPassArg(
       const Symbol &proc, const Symbol *interface, const WithPassArg &);
   void CheckProcBinding(const Symbol &, const ProcBindingDetails &);
   void CheckObjectEntity(const Symbol &, const ObjectEntityDetails &);
   void CheckArraySpec(const Symbol &, const ArraySpec &);
   void CheckProcEntity(const Symbol &, const ProcEntityDetails &);
   void CheckSubprogram(const Symbol &, const SubprogramDetails &);
   void CheckAssumedTypeEntity(const Symbol &, const ObjectEntityDetails &);
   void CheckDerivedType(const Symbol &, const DerivedTypeDetails &);
   void CheckGeneric(const Symbol &, const GenericDetails &);
   std::optional<std::vector<Procedure>> Characterize(const SymbolVector &);
   bool CheckDefinedOperator(const SourceName &, const GenericKind &,
       const Symbol &, const Procedure &);
   std::optional<parser::MessageFixedText> CheckNumberOfArgs(
       const GenericKind &, std::size_t);
   bool CheckDefinedOperatorArg(
       const SourceName &, const Symbol &, const Procedure &, std::size_t);
   bool CheckDefinedAssignment(const Symbol &, const Procedure &);
   bool CheckDefinedAssignmentArg(const Symbol &, const DummyArgument &, int);
   void CheckSpecificsAreDistinguishable(
       const Symbol &, const GenericDetails &, const std::vector<Procedure> &);
   void CheckEquivalenceSet(const EquivalenceSet &);
   void CheckBlockData(const Scope &);
 
   void SayNotDistinguishable(
       const SourceName &, GenericKind, const Symbol &, const Symbol &);
   bool CheckConflicting(const Symbol &, Attr, Attr);
   bool InPure() const {
     return innermostSymbol_ && IsPureProcedure(*innermostSymbol_);
   }
   bool InFunction() const {
     return innermostSymbol_ && IsFunction(*innermostSymbol_);
   }
   template <typename... A>
-  void SayWithDeclaration(const Symbol &symbol, A &&... x) {
+  void SayWithDeclaration(const Symbol &symbol, A &&...x) {
     if (parser::Message * msg{messages_.Say(std::forward<A>(x)...)}) {
       if (messages_.at().begin() != symbol.name().begin()) {
         evaluate::AttachDeclaration(*msg, symbol);
       }
     }
   }
   bool IsResultOkToDiffer(const FunctionResult &);
 
   SemanticsContext &context_;
   evaluate::FoldingContext &foldingContext_{context_.foldingContext()};
   parser::ContextualMessages &messages_{foldingContext_.messages()};
   const Scope *scope_{nullptr};
   // This symbol is the one attached to the innermost enclosing scope
   // that has a symbol.
   const Symbol *innermostSymbol_{nullptr};
 };
 
 void CheckHelper::Check(const ParamValue &value, bool canBeAssumed) {
   if (value.isAssumed()) {
     if (!canBeAssumed) { // C795, C721, C726
       messages_.Say(
           "An assumed (*) type parameter may be used only for a (non-statement"
           " function) dummy argument, associate name, named constant, or"
           " external function result"_err_en_US);
     }
   } else {
     CheckSpecExpr(value.GetExplicit());
   }
 }
 
 void CheckHelper::Check(const ArraySpec &shape) {
   for (const auto &spec : shape) {
     Check(spec);
   }
 }
 
 void CheckHelper::Check(
     const DeclTypeSpec &type, bool canHaveAssumedTypeParameters) {
   if (type.category() == DeclTypeSpec::Character) {
     Check(type.characterTypeSpec().length(), canHaveAssumedTypeParameters);
   } else if (const DerivedTypeSpec * derived{type.AsDerived()}) {
     for (auto &parm : derived->parameters()) {
       Check(parm.second, canHaveAssumedTypeParameters);
     }
   }
 }
 
 void CheckHelper::Check(const Symbol &symbol) {
   if (context_.HasError(symbol)) {
     return;
   }
   const DeclTypeSpec *type{symbol.GetType()};
   const DerivedTypeSpec *derived{type ? type->AsDerived() : nullptr};
   auto restorer{messages_.SetLocation(symbol.name())};
   context_.set_location(symbol.name());
   bool isAssociated{symbol.has<UseDetails>() || symbol.has<HostAssocDetails>()};
   if (symbol.attrs().test(Attr::VOLATILE)) {
     CheckVolatile(symbol, isAssociated, derived);
   }
   if (isAssociated) {
     return; // only care about checking VOLATILE on associated symbols
   }
   if (IsPointer(symbol)) {
     CheckPointer(symbol);
   }
   std::visit(
       common::visitors{
           [&](const ProcBindingDetails &x) { CheckProcBinding(symbol, x); },
           [&](const ObjectEntityDetails &x) { CheckObjectEntity(symbol, x); },
           [&](const ProcEntityDetails &x) { CheckProcEntity(symbol, x); },
           [&](const SubprogramDetails &x) { CheckSubprogram(symbol, x); },
           [&](const DerivedTypeDetails &x) { CheckDerivedType(symbol, x); },
           [&](const GenericDetails &x) { CheckGeneric(symbol, x); },
           [](const auto &) {},
       },
       symbol.details());
   if (InPure()) {
     if (IsSaved(symbol)) {
       messages_.Say(
           "A pure subprogram may not have a variable with the SAVE attribute"_err_en_US);
     }
     if (symbol.attrs().test(Attr::VOLATILE)) {
       messages_.Say(
           "A pure subprogram may not have a variable with the VOLATILE attribute"_err_en_US);
     }
     if (IsProcedure(symbol) && !IsPureProcedure(symbol) && IsDummy(symbol)) {
       messages_.Say(
           "A dummy procedure of a pure subprogram must be pure"_err_en_US);
     }
     if (!IsDummy(symbol) && !IsFunctionResult(symbol)) {
       if (IsPolymorphicAllocatable(symbol)) {
         SayWithDeclaration(symbol,
             "Deallocation of polymorphic object '%s' is not permitted in a pure subprogram"_err_en_US,
             symbol.name());
       } else if (derived) {
         if (auto bad{FindPolymorphicAllocatableUltimateComponent(*derived)}) {
           SayWithDeclaration(*bad,
               "Deallocation of polymorphic object '%s%s' is not permitted in a pure subprogram"_err_en_US,
               symbol.name(), bad.BuildResultDesignatorName());
         }
       }
     }
   }
   if (type) { // Section 7.2, paragraph 7
     bool canHaveAssumedParameter{IsNamedConstant(symbol) ||
         (IsAssumedLengthCharacter(symbol) && // C722
             IsExternal(symbol)) ||
         symbol.test(Symbol::Flag::ParentComp)};
     if (!IsStmtFunctionDummy(symbol)) { // C726
       if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
         canHaveAssumedParameter |= object->isDummy() ||
             (object->isFuncResult() &&
                 type->category() == DeclTypeSpec::Character) ||
             IsStmtFunctionResult(symbol); // Avoids multiple messages
       } else {
         canHaveAssumedParameter |= symbol.has<AssocEntityDetails>();
       }
     }
     Check(*type, canHaveAssumedParameter);
     if (InPure() && InFunction() && IsFunctionResult(symbol)) {
       if (derived && HasImpureFinal(*derived)) { // C1584
         messages_.Say(
             "Result of pure function may not have an impure FINAL subroutine"_err_en_US);
       }
       if (type->IsPolymorphic() && IsAllocatable(symbol)) { // C1585
         messages_.Say(
             "Result of pure function may not be both polymorphic and ALLOCATABLE"_err_en_US);
       }
       if (derived) {
         if (auto bad{FindPolymorphicAllocatableUltimateComponent(*derived)}) {
           SayWithDeclaration(*bad,
               "Result of pure function may not have polymorphic ALLOCATABLE ultimate component '%s'"_err_en_US,
               bad.BuildResultDesignatorName());
         }
       }
     }
   }
   if (IsAssumedLengthCharacter(symbol) && IsExternal(symbol)) { // C723
     if (symbol.attrs().test(Attr::RECURSIVE)) {
       messages_.Say(
           "An assumed-length CHARACTER(*) function cannot be RECURSIVE"_err_en_US);
     }
     if (symbol.Rank() > 0) {
       messages_.Say(
           "An assumed-length CHARACTER(*) function cannot return an array"_err_en_US);
     }
     if (symbol.attrs().test(Attr::PURE)) {
       messages_.Say(
           "An assumed-length CHARACTER(*) function cannot be PURE"_err_en_US);
     }
     if (symbol.attrs().test(Attr::ELEMENTAL)) {
       messages_.Say(
           "An assumed-length CHARACTER(*) function cannot be ELEMENTAL"_err_en_US);
     }
     if (const Symbol * result{FindFunctionResult(symbol)}) {
       if (IsPointer(*result)) {
         messages_.Say(
             "An assumed-length CHARACTER(*) function cannot return a POINTER"_err_en_US);
       }
     }
   }
   if (symbol.attrs().test(Attr::VALUE)) {
     CheckValue(symbol, derived);
   }
   if (symbol.attrs().test(Attr::CONTIGUOUS) && IsPointer(symbol) &&
       symbol.Rank() == 0) { // C830
     messages_.Say("CONTIGUOUS POINTER must be an array"_err_en_US);
   }
   if (IsDummy(symbol)) {
     if (IsNamedConstant(symbol)) {
       messages_.Say(
           "A dummy argument may not also be a named constant"_err_en_US);
     }
     if (IsSaved(symbol)) {
       messages_.Say(
           "A dummy argument may not have the SAVE attribute"_err_en_US);
     }
   } else if (IsFunctionResult(symbol)) {
     if (IsSaved(symbol)) {
       messages_.Say(
           "A function result may not have the SAVE attribute"_err_en_US);
     }
   }
   if (symbol.owner().IsDerivedType() &&
       (symbol.attrs().test(Attr::CONTIGUOUS) &&
           !(IsPointer(symbol) && symbol.Rank() > 0))) { // C752
     messages_.Say(
         "A CONTIGUOUS component must be an array with the POINTER attribute"_err_en_US);
   }
   if (symbol.owner().IsModule() && IsAutomatic(symbol)) {
     messages_.Say(
         "Automatic data object '%s' may not appear in the specification part"
         " of a module"_err_en_US,
         symbol.name());
   }
 }
 
 void CheckHelper::CheckValue(
     const Symbol &symbol, const DerivedTypeSpec *derived) { // C863 - C865
   if (!IsDummy(symbol)) {
     messages_.Say(
         "VALUE attribute may apply only to a dummy argument"_err_en_US);
   }
   if (IsProcedure(symbol)) {
     messages_.Say(
         "VALUE attribute may apply only to a dummy data object"_err_en_US);
   }
   if (IsAssumedSizeArray(symbol)) {
     messages_.Say(
         "VALUE attribute may not apply to an assumed-size array"_err_en_US);
   }
   if (IsCoarray(symbol)) {
     messages_.Say("VALUE attribute may not apply to a coarray"_err_en_US);
   }
   if (IsAllocatable(symbol)) {
     messages_.Say("VALUE attribute may not apply to an ALLOCATABLE"_err_en_US);
   } else if (IsPointer(symbol)) {
     messages_.Say("VALUE attribute may not apply to a POINTER"_err_en_US);
   }
   if (IsIntentInOut(symbol)) {
     messages_.Say(
         "VALUE attribute may not apply to an INTENT(IN OUT) argument"_err_en_US);
   } else if (IsIntentOut(symbol)) {
     messages_.Say(
         "VALUE attribute may not apply to an INTENT(OUT) argument"_err_en_US);
   }
   if (symbol.attrs().test(Attr::VOLATILE)) {
     messages_.Say("VALUE attribute may not apply to a VOLATILE"_err_en_US);
   }
   if (innermostSymbol_ && IsBindCProcedure(*innermostSymbol_) &&
       IsOptional(symbol)) {
     messages_.Say(
         "VALUE attribute may not apply to an OPTIONAL in a BIND(C) procedure"_err_en_US);
   }
   if (derived) {
     if (FindCoarrayUltimateComponent(*derived)) {
       messages_.Say(
           "VALUE attribute may not apply to a type with a coarray ultimate component"_err_en_US);
     }
   }
 }
 
 void CheckHelper::CheckAssumedTypeEntity( // C709
     const Symbol &symbol, const ObjectEntityDetails &details) {
   if (const DeclTypeSpec * type{symbol.GetType()};
       type && type->category() == DeclTypeSpec::TypeStar) {
     if (!IsDummy(symbol)) {
       messages_.Say(
           "Assumed-type entity '%s' must be a dummy argument"_err_en_US,
           symbol.name());
     } else {
       if (symbol.attrs().test(Attr::ALLOCATABLE)) {
         messages_.Say("Assumed-type argument '%s' cannot have the ALLOCATABLE"
                       " attribute"_err_en_US,
             symbol.name());
       }
       if (symbol.attrs().test(Attr::POINTER)) {
         messages_.Say("Assumed-type argument '%s' cannot have the POINTER"
                       " attribute"_err_en_US,
             symbol.name());
       }
       if (symbol.attrs().test(Attr::VALUE)) {
         messages_.Say("Assumed-type argument '%s' cannot have the VALUE"
                       " attribute"_err_en_US,
             symbol.name());
       }
       if (symbol.attrs().test(Attr::INTENT_OUT)) {
         messages_.Say(
             "Assumed-type argument '%s' cannot be INTENT(OUT)"_err_en_US,
             symbol.name());
       }
       if (IsCoarray(symbol)) {
         messages_.Say(
             "Assumed-type argument '%s' cannot be a coarray"_err_en_US,
             symbol.name());
       }
       if (details.IsArray() && details.shape().IsExplicitShape()) {
         messages_.Say(
             "Assumed-type array argument 'arg8' must be assumed shape,"
             " assumed size, or assumed rank"_err_en_US,
             symbol.name());
       }
     }
   }
 }
 
 void CheckHelper::CheckObjectEntity(
     const Symbol &symbol, const ObjectEntityDetails &details) {
   CheckArraySpec(symbol, details.shape());
   Check(details.shape());
   Check(details.coshape());
   CheckAssumedTypeEntity(symbol, details);
   if (!details.coshape().empty()) {
     bool isDeferredShape{details.coshape().IsDeferredShape()};
     if (IsAllocatable(symbol)) {
       if (!isDeferredShape) { // C827
         messages_.Say("'%s' is an ALLOCATABLE coarray and must have a deferred"
                       " coshape"_err_en_US,
             symbol.name());
       }
     } else if (symbol.owner().IsDerivedType()) { // C746
       std::string deferredMsg{
           isDeferredShape ? "" : " and have a deferred coshape"};
       messages_.Say("Component '%s' is a coarray and must have the ALLOCATABLE"
                     " attribute%s"_err_en_US,
           symbol.name(), deferredMsg);
     } else {
       if (!details.coshape().IsAssumedSize()) { // C828
         messages_.Say(
             "Component '%s' is a non-ALLOCATABLE coarray and must have"
             " an explicit coshape"_err_en_US,
             symbol.name());
       }
     }
   }
   if (details.isDummy()) {
     if (symbol.attrs().test(Attr::INTENT_OUT)) {
       if (FindUltimateComponent(symbol, [](const Symbol &x) {
             return IsCoarray(x) && IsAllocatable(x);
           })) { // C846
         messages_.Say(
             "An INTENT(OUT) dummy argument may not be, or contain, an ALLOCATABLE coarray"_err_en_US);
       }
       if (IsOrContainsEventOrLockComponent(symbol)) { // C847
         messages_.Say(
             "An INTENT(OUT) dummy argument may not be, or contain, EVENT_TYPE or LOCK_TYPE"_err_en_US);
       }
     }
     if (InPure() && !IsStmtFunction(DEREF(innermostSymbol_)) &&
         !IsPointer(symbol) && !IsIntentIn(symbol) &&
         !symbol.attrs().test(Attr::VALUE)) {
       if (InFunction()) { // C1583
         messages_.Say(
             "non-POINTER dummy argument of pure function must be INTENT(IN) or VALUE"_err_en_US);
       } else if (IsIntentOut(symbol)) {
         if (const DeclTypeSpec * type{details.type()}) {
           if (type && type->IsPolymorphic()) { // C1588
             messages_.Say(
                 "An INTENT(OUT) dummy argument of a pure subroutine may not be polymorphic"_err_en_US);
           } else if (const DerivedTypeSpec * derived{type->AsDerived()}) {
             if (FindUltimateComponent(*derived, [](const Symbol &x) {
                   const DeclTypeSpec *type{x.GetType()};
                   return type && type->IsPolymorphic();
                 })) { // C1588
               messages_.Say(
                   "An INTENT(OUT) dummy argument of a pure subroutine may not have a polymorphic ultimate component"_err_en_US);
             }
             if (HasImpureFinal(*derived)) { // C1587
               messages_.Say(
                   "An INTENT(OUT) dummy argument of a pure subroutine may not have an impure FINAL subroutine"_err_en_US);
             }
           }
         }
       } else if (!IsIntentInOut(symbol)) { // C1586
         messages_.Say(
             "non-POINTER dummy argument of pure subroutine must have INTENT() or VALUE attribute"_err_en_US);
       }
     }
   }
   if (symbol.owner().kind() != Scope::Kind::DerivedType &&
       IsInitialized(symbol, true /*ignore DATA, already caught*/)) { // C808
     if (IsAutomatic(symbol)) {
       messages_.Say("An automatic variable must not be initialized"_err_en_US);
     } else if (IsDummy(symbol)) {
       messages_.Say("A dummy argument must not be initialized"_err_en_US);
     } else if (IsFunctionResult(symbol)) {
       messages_.Say("A function result must not be initialized"_err_en_US);
     } else if (IsInBlankCommon(symbol)) {
       messages_.Say(
           "A variable in blank COMMON should not be initialized"_en_US);
     }
   }
   if (symbol.owner().kind() == Scope::Kind::BlockData &&
       IsInitialized(symbol)) {
     if (IsAllocatable(symbol)) {
       messages_.Say(
           "An ALLOCATABLE variable may not appear in a BLOCK DATA subprogram"_err_en_US);
     } else if (!FindCommonBlockContaining(symbol)) {
       messages_.Say(
           "An initialized variable in BLOCK DATA must be in a COMMON block"_err_en_US);
     }
   }
   if (const DeclTypeSpec * type{details.type()}) { // C708
     if (type->IsPolymorphic() &&
         !(type->IsAssumedType() || IsAllocatableOrPointer(symbol) ||
             IsDummy(symbol))) {
       messages_.Say("CLASS entity '%s' must be a dummy argument or have "
                     "ALLOCATABLE or POINTER attribute"_err_en_US,
           symbol.name());
     }
   }
 }
 
 // The six different kinds of array-specs:
 //   array-spec     -> explicit-shape-list | deferred-shape-list
 //                     | assumed-shape-list | implied-shape-list
 //                     | assumed-size | assumed-rank
 //   explicit-shape -> [ lb : ] ub
 //   deferred-shape -> :
 //   assumed-shape  -> [ lb ] :
 //   implied-shape  -> [ lb : ] *
 //   assumed-size   -> [ explicit-shape-list , ] [ lb : ] *
 //   assumed-rank   -> ..
 // Note:
 // - deferred-shape is also an assumed-shape
 // - A single "*" or "lb:*" might be assumed-size or implied-shape-list
 void CheckHelper::CheckArraySpec(
     const Symbol &symbol, const ArraySpec &arraySpec) {
   if (arraySpec.Rank() == 0) {
     return;
   }
   bool isExplicit{arraySpec.IsExplicitShape()};
   bool isDeferred{arraySpec.IsDeferredShape()};
   bool isImplied{arraySpec.IsImpliedShape()};
   bool isAssumedShape{arraySpec.IsAssumedShape()};
   bool isAssumedSize{arraySpec.IsAssumedSize()};
   bool isAssumedRank{arraySpec.IsAssumedRank()};
   std::optional<parser::MessageFixedText> msg;
   if (symbol.test(Symbol::Flag::CrayPointee) && !isExplicit && !isAssumedSize) {
     msg = "Cray pointee '%s' must have must have explicit shape or"
           " assumed size"_err_en_US;
   } else if (IsAllocatableOrPointer(symbol) && !isDeferred && !isAssumedRank) {
     if (symbol.owner().IsDerivedType()) { // C745
       if (IsAllocatable(symbol)) {
         msg = "Allocatable array component '%s' must have"
               " deferred shape"_err_en_US;
       } else {
         msg = "Array pointer component '%s' must have deferred shape"_err_en_US;
       }
     } else {
       if (IsAllocatable(symbol)) { // C832
         msg = "Allocatable array '%s' must have deferred shape or"
               " assumed rank"_err_en_US;
       } else {
         msg = "Array pointer '%s' must have deferred shape or"
               " assumed rank"_err_en_US;
       }
     }
   } else if (IsDummy(symbol)) {
     if (isImplied && !isAssumedSize) { // C836
       msg = "Dummy array argument '%s' may not have implied shape"_err_en_US;
     }
   } else if (isAssumedShape && !isDeferred) {
     msg = "Assumed-shape array '%s' must be a dummy argument"_err_en_US;
   } else if (isAssumedSize && !isImplied) { // C833
     msg = "Assumed-size array '%s' must be a dummy argument"_err_en_US;
   } else if (isAssumedRank) { // C837
     msg = "Assumed-rank array '%s' must be a dummy argument"_err_en_US;
   } else if (isImplied) {
     if (!IsNamedConstant(symbol)) { // C836
       msg = "Implied-shape array '%s' must be a named constant"_err_en_US;
     }
   } else if (IsNamedConstant(symbol)) {
     if (!isExplicit && !isImplied) {
       msg = "Named constant '%s' array must have explicit or"
             " implied shape"_err_en_US;
     }
   } else if (!IsAllocatableOrPointer(symbol) && !isExplicit) {
     if (symbol.owner().IsDerivedType()) { // C749
       msg = "Component array '%s' without ALLOCATABLE or POINTER attribute must"
             " have explicit shape"_err_en_US;
     } else { // C816
       msg = "Array '%s' without ALLOCATABLE or POINTER attribute must have"
             " explicit shape"_err_en_US;
     }
   }
   if (msg) {
     context_.Say(std::move(*msg), symbol.name());
   }
 }
 
 void CheckHelper::CheckProcEntity(
     const Symbol &symbol, const ProcEntityDetails &details) {
   if (details.isDummy()) {
     const Symbol *interface{details.interface().symbol()};
     if (!symbol.attrs().test(Attr::INTRINSIC) &&
         (symbol.attrs().test(Attr::ELEMENTAL) ||
             (interface && !interface->attrs().test(Attr::INTRINSIC) &&
                 interface->attrs().test(Attr::ELEMENTAL)))) {
       // There's no explicit constraint or "shall" that we can find in the
       // standard for this check, but it seems to be implied in multiple
       // sites, and ELEMENTAL non-intrinsic actual arguments *are*
       // explicitly forbidden.  But we allow "PROCEDURE(SIN)::dummy"
       // because it is explicitly legal to *pass* the specific intrinsic
       // function SIN as an actual argument.
       messages_.Say("A dummy procedure may not be ELEMENTAL"_err_en_US);
     }
   } else if (symbol.owner().IsDerivedType()) {
     if (!symbol.attrs().test(Attr::POINTER)) { // C756
       const auto &name{symbol.name()};
       messages_.Say(name,
           "Procedure component '%s' must have POINTER attribute"_err_en_US,
           name);
     }
     CheckPassArg(symbol, details.interface().symbol(), details);
   }
   if (symbol.attrs().test(Attr::POINTER)) {
     if (const Symbol * interface{details.interface().symbol()}) {
       if (interface->attrs().test(Attr::ELEMENTAL) &&
           !interface->attrs().test(Attr::INTRINSIC)) {
         messages_.Say("Procedure pointer '%s' may not be ELEMENTAL"_err_en_US,
             symbol.name()); // C1517
       }
     }
   } else if (symbol.attrs().test(Attr::SAVE)) {
     messages_.Say(
         "Procedure '%s' with SAVE attribute must also have POINTER attribute"_err_en_US,
         symbol.name());
   }
 }
 
 // When a module subprogram has the MODULE prefix the following must match
 // with the corresponding separate module procedure interface body:
 // - C1549: characteristics and dummy argument names
 // - C1550: binding label
 // - C1551: NON_RECURSIVE prefix
 class SubprogramMatchHelper {
 public:
   explicit SubprogramMatchHelper(SemanticsContext &context)
       : context{context} {}
 
   void Check(const Symbol &, const Symbol &);
 
 private:
   void CheckDummyArg(const Symbol &, const Symbol &, const DummyArgument &,
       const DummyArgument &);
   void CheckDummyDataObject(const Symbol &, const Symbol &,
       const DummyDataObject &, const DummyDataObject &);
   void CheckDummyProcedure(const Symbol &, const Symbol &,
       const DummyProcedure &, const DummyProcedure &);
   bool CheckSameIntent(
       const Symbol &, const Symbol &, common::Intent, common::Intent);
   template <typename... A>
   void Say(
       const Symbol &, const Symbol &, parser::MessageFixedText &&, A &&...);
   template <typename ATTRS>
   bool CheckSameAttrs(const Symbol &, const Symbol &, ATTRS, ATTRS);
   bool ShapesAreCompatible(const DummyDataObject &, const DummyDataObject &);
   evaluate::Shape FoldShape(const evaluate::Shape &);
   std::string AsFortran(DummyDataObject::Attr attr) {
     return parser::ToUpperCaseLetters(DummyDataObject::EnumToString(attr));
   }
   std::string AsFortran(DummyProcedure::Attr attr) {
     return parser::ToUpperCaseLetters(DummyProcedure::EnumToString(attr));
   }
 
   SemanticsContext &context;
 };
 
 // 15.6.2.6 para 3 - can the result of an ENTRY differ from its function?
 bool CheckHelper::IsResultOkToDiffer(const FunctionResult &result) {
   if (result.attrs.test(FunctionResult::Attr::Allocatable) ||
       result.attrs.test(FunctionResult::Attr::Pointer)) {
     return false;
   }
   const auto *typeAndShape{result.GetTypeAndShape()};
   if (!typeAndShape || typeAndShape->Rank() != 0) {
     return false;
   }
   auto category{typeAndShape->type().category()};
   if (category == TypeCategory::Character ||
       category == TypeCategory::Derived) {
     return false;
   }
   int kind{typeAndShape->type().kind()};
   return kind == context_.GetDefaultKind(category) ||
       (category == TypeCategory::Real &&
           kind == context_.doublePrecisionKind());
 }
 
 void CheckHelper::CheckSubprogram(
     const Symbol &symbol, const SubprogramDetails &details) {
   if (const Symbol * iface{FindSeparateModuleSubprogramInterface(&symbol)}) {
     SubprogramMatchHelper{context_}.Check(symbol, *iface);
   }
   if (const Scope * entryScope{details.entryScope()}) {
     // ENTRY 15.6.2.6, esp. C1571
     std::optional<parser::MessageFixedText> error;
     const Symbol *subprogram{entryScope->symbol()};
     const SubprogramDetails *subprogramDetails{nullptr};
     if (subprogram) {
       subprogramDetails = subprogram->detailsIf<SubprogramDetails>();
     }
     if (entryScope->kind() != Scope::Kind::Subprogram) {
       error = "ENTRY may appear only in a subroutine or function"_err_en_US;
     } else if (!(entryScope->parent().IsGlobal() ||
                    entryScope->parent().IsModule() ||
                    entryScope->parent().IsSubmodule())) {
       error = "ENTRY may not appear in an internal subprogram"_err_en_US;
     } else if (FindSeparateModuleSubprogramInterface(subprogram)) {
       error = "ENTRY may not appear in a separate module procedure"_err_en_US;
     } else if (subprogramDetails && details.isFunction() &&
         subprogramDetails->isFunction()) {
       auto result{FunctionResult::Characterize(
           details.result(), context_.intrinsics())};
       auto subpResult{FunctionResult::Characterize(
           subprogramDetails->result(), context_.intrinsics())};
       if (result && subpResult && *result != *subpResult &&
           (!IsResultOkToDiffer(*result) || !IsResultOkToDiffer(*subpResult))) {
         error =
             "Result of ENTRY is not compatible with result of containing function"_err_en_US;
       }
     }
     if (error) {
       if (auto *msg{messages_.Say(symbol.name(), *error)}) {
         if (subprogram) {
           msg->Attach(subprogram->name(), "Containing subprogram"_en_US);
         }
       }
     }
   }
 }
 
 void CheckHelper::CheckDerivedType(
     const Symbol &symbol, const DerivedTypeDetails &details) {
   const Scope *scope{symbol.scope()};
   if (!scope) {
     CHECK(details.isForwardReferenced());
     return;
   }
   CHECK(scope->symbol() == &symbol);
   CHECK(scope->IsDerivedType());
   if (symbol.attrs().test(Attr::ABSTRACT) && // C734
       (symbol.attrs().test(Attr::BIND_C) || details.sequence())) {
     messages_.Say("An ABSTRACT derived type must be extensible"_err_en_US);
   }
   if (const DeclTypeSpec * parent{FindParentTypeSpec(symbol)}) {
     const DerivedTypeSpec *parentDerived{parent->AsDerived()};
     if (!IsExtensibleType(parentDerived)) { // C705
       messages_.Say("The parent type is not extensible"_err_en_US);
     }
     if (!symbol.attrs().test(Attr::ABSTRACT) && parentDerived &&
         parentDerived->typeSymbol().attrs().test(Attr::ABSTRACT)) {
       ScopeComponentIterator components{*parentDerived};
       for (const Symbol &component : components) {
         if (component.attrs().test(Attr::DEFERRED)) {
           if (scope->FindComponent(component.name()) == &component) {
             SayWithDeclaration(component,
                 "Non-ABSTRACT extension of ABSTRACT derived type '%s' lacks a binding for DEFERRED procedure '%s'"_err_en_US,
                 parentDerived->typeSymbol().name(), component.name());
           }
         }
       }
     }
     DerivedTypeSpec derived{symbol.name(), symbol};
     derived.set_scope(*scope);
     if (FindCoarrayUltimateComponent(derived) && // C736
         !(parentDerived && FindCoarrayUltimateComponent(*parentDerived))) {
       messages_.Say(
           "Type '%s' has a coarray ultimate component so the type at the base "
           "of its type extension chain ('%s') must be a type that has a "
           "coarray ultimate component"_err_en_US,
           symbol.name(), scope->GetDerivedTypeBase().GetSymbol()->name());
     }
     if (FindEventOrLockPotentialComponent(derived) && // C737
         !(FindEventOrLockPotentialComponent(*parentDerived) ||
             IsEventTypeOrLockType(parentDerived))) {
       messages_.Say(
           "Type '%s' has an EVENT_TYPE or LOCK_TYPE component, so the type "
           "at the base of its type extension chain ('%s') must either have an "
           "EVENT_TYPE or LOCK_TYPE component, or be EVENT_TYPE or "
           "LOCK_TYPE"_err_en_US,
           symbol.name(), scope->GetDerivedTypeBase().GetSymbol()->name());
     }
   }
   if (HasIntrinsicTypeName(symbol)) { // C729
     messages_.Say("A derived type name cannot be the name of an intrinsic"
                   " type"_err_en_US);
   }
 }
 
 void CheckHelper::CheckGeneric(
     const Symbol &symbol, const GenericDetails &details) {
   const SymbolVector &specifics{details.specificProcs()};
   const auto &bindingNames{details.bindingNames()};
   std::optional<std::vector<Procedure>> procs{Characterize(specifics)};
   if (!procs) {
     return;
   }
   bool ok{true};
   if (details.kind().IsIntrinsicOperator()) {
     for (std::size_t i{0}; i < specifics.size(); ++i) {
       auto restorer{messages_.SetLocation(bindingNames[i])};
       ok &= CheckDefinedOperator(
           symbol.name(), details.kind(), specifics[i], (*procs)[i]);
     }
   }
   if (details.kind().IsAssignment()) {
     for (std::size_t i{0}; i < specifics.size(); ++i) {
       auto restorer{messages_.SetLocation(bindingNames[i])};
       ok &= CheckDefinedAssignment(specifics[i], (*procs)[i]);
     }
   }
   if (ok) {
     CheckSpecificsAreDistinguishable(symbol, details, *procs);
   }
 }
 
 // Check that the specifics of this generic are distinguishable from each other
 void CheckHelper::CheckSpecificsAreDistinguishable(const Symbol &generic,
     const GenericDetails &details, const std::vector<Procedure> &procs) {
   const SymbolVector &specifics{details.specificProcs()};
   std::size_t count{specifics.size()};
   if (count < 2) {
     return;
   }
   GenericKind kind{details.kind()};
   auto distinguishable{kind.IsAssignment() || kind.IsOperator()
           ? evaluate::characteristics::DistinguishableOpOrAssign
           : evaluate::characteristics::Distinguishable};
   for (std::size_t i1{0}; i1 < count - 1; ++i1) {
     auto &proc1{procs[i1]};
     for (std::size_t i2{i1 + 1}; i2 < count; ++i2) {
       auto &proc2{procs[i2]};
       if (!distinguishable(proc1, proc2)) {
         SayNotDistinguishable(
             generic.name(), kind, specifics[i1], specifics[i2]);
       }
     }
   }
 }
 
 void CheckHelper::SayNotDistinguishable(const SourceName &name,
     GenericKind kind, const Symbol &proc1, const Symbol &proc2) {
   auto &&text{kind.IsDefinedOperator()
           ? "Generic operator '%s' may not have specific procedures '%s'"
             " and '%s' as their interfaces are not distinguishable"_err_en_US
           : "Generic '%s' may not have specific procedures '%s'"
             " and '%s' as their interfaces are not distinguishable"_err_en_US};
   auto &msg{
       context_.Say(name, std::move(text), name, proc1.name(), proc2.name())};
   evaluate::AttachDeclaration(msg, proc1);
   evaluate::AttachDeclaration(msg, proc2);
 }
 
 static bool ConflictsWithIntrinsicAssignment(const Procedure &proc) {
   auto lhs{std::get<DummyDataObject>(proc.dummyArguments[0].u).type};
   auto rhs{std::get<DummyDataObject>(proc.dummyArguments[1].u).type};
   return Tristate::No ==
       IsDefinedAssignment(lhs.type(), lhs.Rank(), rhs.type(), rhs.Rank());
 }
 
 static bool ConflictsWithIntrinsicOperator(
     const GenericKind &kind, const Procedure &proc) {
   auto arg0{std::get<DummyDataObject>(proc.dummyArguments[0].u).type};
   auto type0{arg0.type()};
   if (proc.dummyArguments.size() == 1) { // unary
     return std::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(
         common::visitors{
             [&](common::NumericOperator) {
               return IsIntrinsicNumeric(type0, rank0, type1, rank1);
             },
             [&](common::LogicalOperator) {
               return IsIntrinsicLogical(type0, rank0, type1, rank1);
             },
             [&](common::RelationalOperator opr) {
               return IsIntrinsicRelational(opr, type0, rank0, type1, rank1);
             },
             [&](GenericKind::OtherKind x) {
               CHECK(x == GenericKind::OtherKind::Concat);
               return IsIntrinsicConcat(type0, rank0, type1, rank1);
             },
             [](const auto &) -> bool { DIE("bad generic kind"); },
         },
         kind.u);
   }
 }
 
 // Check if this procedure can be used for defined operators (see 15.4.3.4.2).
 bool CheckHelper::CheckDefinedOperator(const SourceName &opName,
     const GenericKind &kind, const Symbol &specific, const Procedure &proc) {
   std::optional<parser::MessageFixedText> msg;
   if (specific.attrs().test(Attr::NOPASS)) { // C774
     msg = "%s procedure '%s' may not have NOPASS attribute"_err_en_US;
   } else if (!proc.functionResult.has_value()) {
     msg = "%s procedure '%s' must be a function"_err_en_US;
   } else if (proc.functionResult->IsAssumedLengthCharacter()) {
     msg = "%s function '%s' may not have assumed-length CHARACTER(*)"
           " result"_err_en_US;
   } else if (auto m{CheckNumberOfArgs(kind, proc.dummyArguments.size())}) {
     msg = std::move(m);
   } else if (!CheckDefinedOperatorArg(opName, specific, proc, 0) |
       !CheckDefinedOperatorArg(opName, specific, proc, 1)) {
     return false; // error was reported
   } else if (ConflictsWithIntrinsicOperator(kind, proc)) {
     msg = "%s function '%s' conflicts with intrinsic operator"_err_en_US;
   } else {
     return true; // OK
   }
   SayWithDeclaration(specific, std::move(msg.value()),
       parser::ToUpperCaseLetters(opName.ToString()), specific.name());
   return false;
 }
 
 // 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) {
   std::size_t min{2}, max{2}; // allowed number of args; default is binary
   std::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 {
     return "%s function '%s' must have one or two dummy arguments"_err_en_US;
   }
 }
 
 bool CheckHelper::CheckDefinedOperatorArg(const SourceName &opName,
     const Symbol &symbol, const Procedure &proc, std::size_t pos) {
   if (pos >= proc.dummyArguments.size()) {
     return true;
   }
   auto &arg{proc.dummyArguments.at(pos)};
   std::optional<parser::MessageFixedText> msg;
   if (arg.IsOptional()) {
     msg = "In %s function '%s', dummy argument '%s' may not be"
           " OPTIONAL"_err_en_US;
   } else if (const auto *dataObject{std::get_if<DummyDataObject>(&arg.u)};
              dataObject == nullptr) {
     msg = "In %s function '%s', dummy argument '%s' must be a"
           " data object"_err_en_US;
   } else if (dataObject->intent != common::Intent::In &&
       !dataObject->attrs.test(DummyDataObject::Attr::Value)) {
     msg = "In %s function '%s', dummy argument '%s' must have INTENT(IN)"
           " or VALUE attribute"_err_en_US;
   }
   if (msg) {
     SayWithDeclaration(symbol, std::move(*msg),
         parser::ToUpperCaseLetters(opName.ToString()), symbol.name(), arg.name);
     return false;
   }
   return true;
 }
 
 // Check if this procedure can be used for defined assignment (see 15.4.3.4.3).
 bool CheckHelper::CheckDefinedAssignment(
     const Symbol &specific, const Procedure &proc) {
   std::optional<parser::MessageFixedText> msg;
   if (specific.attrs().test(Attr::NOPASS)) { // C774
     msg = "Defined assignment procedure '%s' may not have"
           " NOPASS attribute"_err_en_US;
   } else if (!proc.IsSubroutine()) {
     msg = "Defined assignment procedure '%s' must be a subroutine"_err_en_US;
   } else if (proc.dummyArguments.size() != 2) {
     msg = "Defined assignment subroutine '%s' must have"
           " two dummy arguments"_err_en_US;
   } else if (!CheckDefinedAssignmentArg(specific, proc.dummyArguments[0], 0) |
       !CheckDefinedAssignmentArg(specific, proc.dummyArguments[1], 1)) {
     return false; // error was reported
   } else if (ConflictsWithIntrinsicAssignment(proc)) {
     msg = "Defined assignment subroutine '%s' conflicts with"
           " intrinsic assignment"_err_en_US;
   } else {
     return true; // OK
   }
   SayWithDeclaration(specific, std::move(msg.value()), specific.name());
   return false;
 }
 
 bool CheckHelper::CheckDefinedAssignmentArg(
     const Symbol &symbol, const DummyArgument &arg, int pos) {
   std::optional<parser::MessageFixedText> msg;
   if (arg.IsOptional()) {
     msg = "In defined assignment subroutine '%s', dummy argument '%s'"
           " may not be OPTIONAL"_err_en_US;
   } else if (const auto *dataObject{std::get_if<DummyDataObject>(&arg.u)}) {
     if (pos == 0) {
       if (dataObject->intent != common::Intent::Out &&
           dataObject->intent != common::Intent::InOut) {
         msg = "In defined assignment subroutine '%s', first dummy argument '%s'"
               " must have INTENT(OUT) or INTENT(INOUT)"_err_en_US;
       }
     } else if (pos == 1) {
       if (dataObject->intent != common::Intent::In &&
           !dataObject->attrs.test(DummyDataObject::Attr::Value)) {
         msg =
             "In defined assignment subroutine '%s', second dummy"
             " argument '%s' must have INTENT(IN) or VALUE attribute"_err_en_US;
       }
     } else {
       DIE("pos must be 0 or 1");
     }
   } else {
     msg = "In defined assignment subroutine '%s', dummy argument '%s'"
           " must be a data object"_err_en_US;
   }
   if (msg) {
     SayWithDeclaration(symbol, std::move(*msg), symbol.name(), arg.name);
     return false;
   }
   return true;
 }
 
 // Report a conflicting attribute error if symbol has both of these attributes
 bool CheckHelper::CheckConflicting(const Symbol &symbol, Attr a1, Attr a2) {
   if (symbol.attrs().test(a1) && symbol.attrs().test(a2)) {
     messages_.Say("'%s' may not have both the %s and %s attributes"_err_en_US,
         symbol.name(), EnumToString(a1), EnumToString(a2));
     return true;
   } else {
     return false;
   }
 }
 
 std::optional<std::vector<Procedure>> CheckHelper::Characterize(
     const SymbolVector &specifics) {
   std::vector<Procedure> result;
   for (const Symbol &specific : specifics) {
     auto proc{Procedure::Characterize(specific, context_.intrinsics())};
     if (!proc || context_.HasError(specific)) {
       return std::nullopt;
     }
     result.emplace_back(*proc);
   }
   return result;
 }
 
 void CheckHelper::CheckVolatile(const Symbol &symbol, bool isAssociated,
     const DerivedTypeSpec *derived) { // C866 - C868
   if (IsIntentIn(symbol)) {
     messages_.Say(
         "VOLATILE attribute may not apply to an INTENT(IN) argument"_err_en_US);
   }
   if (IsProcedure(symbol)) {
     messages_.Say("VOLATILE attribute may apply only to a variable"_err_en_US);
   }
   if (isAssociated) {
     const Symbol &ultimate{symbol.GetUltimate()};
     if (IsCoarray(ultimate)) {
       messages_.Say(
           "VOLATILE attribute may not apply to a coarray accessed by USE or host association"_err_en_US);
     }
     if (derived) {
       if (FindCoarrayUltimateComponent(*derived)) {
         messages_.Say(
             "VOLATILE attribute may not apply to a type with a coarray ultimate component accessed by USE or host association"_err_en_US);
       }
     }
   }
 }
 
 void CheckHelper::CheckPointer(const Symbol &symbol) { // C852
   CheckConflicting(symbol, Attr::POINTER, Attr::TARGET);
   CheckConflicting(symbol, Attr::POINTER, Attr::ALLOCATABLE); // C751
   CheckConflicting(symbol, Attr::POINTER, Attr::INTRINSIC);
   if (symbol.Corank() > 0) {
     messages_.Say(
         "'%s' may not have the POINTER attribute because it is a coarray"_err_en_US,
         symbol.name());
   }
 }
 
 // C760 constraints on the passed-object dummy argument
 // C757 constraints on procedure pointer components
 void CheckHelper::CheckPassArg(
     const Symbol &proc, const Symbol *interface, const WithPassArg &details) {
   if (proc.attrs().test(Attr::NOPASS)) {
     return;
   }
   const auto &name{proc.name()};
   if (!interface) {
     messages_.Say(name,
         "Procedure component '%s' must have NOPASS attribute or explicit interface"_err_en_US,
         name);
     return;
   }
   const auto *subprogram{interface->detailsIf<SubprogramDetails>()};
   if (!subprogram) {
     messages_.Say(name,
         "Procedure component '%s' has invalid interface '%s'"_err_en_US, name,
         interface->name());
     return;
   }
   std::optional<SourceName> passName{details.passName()};
   const auto &dummyArgs{subprogram->dummyArgs()};
   if (!passName) {
     if (dummyArgs.empty()) {
       messages_.Say(name,
           proc.has<ProcEntityDetails>()
               ? "Procedure component '%s' with no dummy arguments"
                 " must have NOPASS attribute"_err_en_US
               : "Procedure binding '%s' with no dummy arguments"
                 " must have NOPASS attribute"_err_en_US,
           name);
       return;
     }
     passName = dummyArgs[0]->name();
   }
   std::optional<int> passArgIndex{};
   for (std::size_t i{0}; i < dummyArgs.size(); ++i) {
     if (dummyArgs[i] && dummyArgs[i]->name() == *passName) {
       passArgIndex = i;
       break;
     }
   }
   if (!passArgIndex) { // C758
     messages_.Say(*passName,
         "'%s' is not a dummy argument of procedure interface '%s'"_err_en_US,
         *passName, interface->name());
     return;
   }
   const Symbol &passArg{*dummyArgs[*passArgIndex]};
   std::optional<parser::MessageFixedText> msg;
   if (!passArg.has<ObjectEntityDetails>()) {
     msg = "Passed-object dummy argument '%s' of procedure '%s'"
           " must be a data object"_err_en_US;
   } else if (passArg.attrs().test(Attr::POINTER)) {
     msg = "Passed-object dummy argument '%s' of procedure '%s'"
           " may not have the POINTER attribute"_err_en_US;
   } else if (passArg.attrs().test(Attr::ALLOCATABLE)) {
     msg = "Passed-object dummy argument '%s' of procedure '%s'"
           " may not have the ALLOCATABLE attribute"_err_en_US;
   } else if (passArg.attrs().test(Attr::VALUE)) {
     msg = "Passed-object dummy argument '%s' of procedure '%s'"
           " may not have the VALUE attribute"_err_en_US;
   } else if (passArg.Rank() > 0) {
     msg = "Passed-object dummy argument '%s' of procedure '%s'"
           " must be scalar"_err_en_US;
   }
   if (msg) {
     messages_.Say(name, std::move(*msg), passName.value(), name);
     return;
   }
   const DeclTypeSpec *type{passArg.GetType()};
   if (!type) {
     return; // an error already occurred
   }
   const Symbol &typeSymbol{*proc.owner().GetSymbol()};
   const DerivedTypeSpec *derived{type->AsDerived()};
   if (!derived || derived->typeSymbol() != typeSymbol) {
     messages_.Say(name,
         "Passed-object dummy argument '%s' of procedure '%s'"
         " must be of type '%s' but is '%s'"_err_en_US,
         passName.value(), name, typeSymbol.name(), type->AsFortran());
     return;
   }
   if (IsExtensibleType(derived) != type->IsPolymorphic()) {
     messages_.Say(name,
         type->IsPolymorphic()
             ? "Passed-object dummy argument '%s' of procedure '%s'"
               " may not be polymorphic because '%s' is not extensible"_err_en_US
             : "Passed-object dummy argument '%s' of procedure '%s'"
               " must be polymorphic because '%s' is extensible"_err_en_US,
         passName.value(), name, typeSymbol.name());
     return;
   }
   for (const auto &[paramName, paramValue] : derived->parameters()) {
     if (paramValue.isLen() && !paramValue.isAssumed()) {
       messages_.Say(name,
           "Passed-object dummy argument '%s' of procedure '%s'"
           " has non-assumed length parameter '%s'"_err_en_US,
           passName.value(), name, paramName);
     }
   }
 }
 
 void CheckHelper::CheckProcBinding(
     const Symbol &symbol, const ProcBindingDetails &binding) {
   const Scope &dtScope{symbol.owner()};
   CHECK(dtScope.kind() == Scope::Kind::DerivedType);
   if (const Symbol * dtSymbol{dtScope.symbol()}) {
     if (symbol.attrs().test(Attr::DEFERRED)) {
       if (!dtSymbol->attrs().test(Attr::ABSTRACT)) { // C733
         SayWithDeclaration(*dtSymbol,
             "Procedure bound to non-ABSTRACT derived type '%s' may not be DEFERRED"_err_en_US,
             dtSymbol->name());
       }
       if (symbol.attrs().test(Attr::NON_OVERRIDABLE)) {
         messages_.Say(
             "Type-bound procedure '%s' may not be both DEFERRED and NON_OVERRIDABLE"_err_en_US,
             symbol.name());
       }
     }
   }
   if (const Symbol * overridden{FindOverriddenBinding(symbol)}) {
     if (overridden->attrs().test(Attr::NON_OVERRIDABLE)) {
       SayWithDeclaration(*overridden,
           "Override of NON_OVERRIDABLE '%s' is not permitted"_err_en_US,
           symbol.name());
     }
     if (const auto *overriddenBinding{
             overridden->detailsIf<ProcBindingDetails>()}) {
       if (!IsPureProcedure(symbol) && IsPureProcedure(*overridden)) {
         SayWithDeclaration(*overridden,
             "An overridden pure type-bound procedure binding must also be pure"_err_en_US);
         return;
       }
       if (!binding.symbol().attrs().test(Attr::ELEMENTAL) &&
           overriddenBinding->symbol().attrs().test(Attr::ELEMENTAL)) {
         SayWithDeclaration(*overridden,
             "A type-bound procedure and its override must both, or neither, be ELEMENTAL"_err_en_US);
         return;
       }
       bool isNopass{symbol.attrs().test(Attr::NOPASS)};
       if (isNopass != overridden->attrs().test(Attr::NOPASS)) {
         SayWithDeclaration(*overridden,
             isNopass
                 ? "A NOPASS type-bound procedure may not override a passed-argument procedure"_err_en_US
                 : "A passed-argument type-bound procedure may not override a NOPASS procedure"_err_en_US);
       } else {
         auto bindingChars{evaluate::characteristics::Procedure::Characterize(
             binding.symbol(), context_.intrinsics())};
         auto overriddenChars{evaluate::characteristics::Procedure::Characterize(
             overriddenBinding->symbol(), context_.intrinsics())};
         if (bindingChars && overriddenChars) {
           if (isNopass) {
             if (!bindingChars->CanOverride(*overriddenChars, std::nullopt)) {
               SayWithDeclaration(*overridden,
                   "A type-bound procedure and its override must have compatible interfaces"_err_en_US);
             }
           } else {
             int passIndex{bindingChars->FindPassIndex(binding.passName())};
             int overriddenPassIndex{
                 overriddenChars->FindPassIndex(overriddenBinding->passName())};
             if (passIndex != overriddenPassIndex) {
               SayWithDeclaration(*overridden,
                   "A type-bound procedure and its override must use the same PASS argument"_err_en_US);
             } else if (!bindingChars->CanOverride(
                            *overriddenChars, passIndex)) {
               SayWithDeclaration(*overridden,
                   "A type-bound procedure and its override must have compatible interfaces apart from their passed argument"_err_en_US);
             }
           }
         }
       }
       if (symbol.attrs().test(Attr::PRIVATE) &&
           overridden->attrs().test(Attr::PUBLIC)) {
         SayWithDeclaration(*overridden,
             "A PRIVATE procedure may not override a PUBLIC procedure"_err_en_US);
       }
     } else {
       SayWithDeclaration(*overridden,
           "A type-bound procedure binding may not have the same name as a parent component"_err_en_US);
     }
   }
   CheckPassArg(symbol, &binding.symbol(), binding);
 }
 
 void CheckHelper::Check(const Scope &scope) {
   scope_ = &scope;
   common::Restorer<const Symbol *> restorer{innermostSymbol_};
   if (const Symbol * symbol{scope.symbol()}) {
     innermostSymbol_ = symbol;
   } else if (scope.IsDerivedType()) {
     return; // PDT instantiations have null symbol()
   }
   for (const auto &set : scope.equivalenceSets()) {
     CheckEquivalenceSet(set);
   }
   for (const auto &pair : scope) {
     Check(*pair.second);
   }
   for (const Scope &child : scope.children()) {
     Check(child);
   }
   if (scope.kind() == Scope::Kind::BlockData) {
     CheckBlockData(scope);
   }
 }
 
 void CheckHelper::CheckEquivalenceSet(const EquivalenceSet &set) {
   auto iter{
       std::find_if(set.begin(), set.end(), [](const EquivalenceObject &object) {
         return FindCommonBlockContaining(object.symbol) != nullptr;
       })};
   if (iter != set.end()) {
     const Symbol &commonBlock{DEREF(FindCommonBlockContaining(iter->symbol))};
     for (auto &object : set) {
       if (&object != &*iter) {
         if (auto *details{object.symbol.detailsIf<ObjectEntityDetails>()}) {
           if (details->commonBlock()) {
             if (details->commonBlock() != &commonBlock) { // 8.10.3 paragraph 1
               if (auto *msg{messages_.Say(object.symbol.name(),
                       "Two objects in the same EQUIVALENCE set may not be members of distinct COMMON blocks"_err_en_US)}) {
                 msg->Attach(iter->symbol.name(),
                        "Other object in EQUIVALENCE set"_en_US)
                     .Attach(details->commonBlock()->name(),
                         "COMMON block containing '%s'"_en_US,
                         object.symbol.name())
                     .Attach(commonBlock.name(),
                         "COMMON block containing '%s'"_en_US,
                         iter->symbol.name());
               }
             }
           } else {
             // Mark all symbols in the equivalence set with the same COMMON
             // block to prevent spurious error messages about initialization
             // in BLOCK DATA outside COMMON
             details->set_commonBlock(commonBlock);
           }
         }
       }
     }
   }
   // TODO: Move C8106 (&al.) checks here from resolve-names-utils.cpp
 }
 
 void CheckHelper::CheckBlockData(const Scope &scope) {
   // BLOCK DATA subprograms should contain only named common blocks.
   // C1415 presents a list of statements that shouldn't appear in
   // BLOCK DATA, but so long as the subprogram contains no executable
   // code and allocates no storage outside named COMMON, we're happy
   // (e.g., an ENUM is strictly not allowed).
   for (const auto &pair : scope) {
     const Symbol &symbol{*pair.second};
     if (!(symbol.has<CommonBlockDetails>() || symbol.has<UseDetails>() ||
             symbol.has<UseErrorDetails>() || symbol.has<DerivedTypeDetails>() ||
             symbol.has<SubprogramDetails>() ||
             symbol.has<ObjectEntityDetails>() ||
             (symbol.has<ProcEntityDetails>() &&
                 !symbol.attrs().test(Attr::POINTER)))) {
       messages_.Say(symbol.name(),
           "'%s' may not appear in a BLOCK DATA subprogram"_err_en_US,
           symbol.name());
     }
   }
 }
 
 void SubprogramMatchHelper::Check(
     const Symbol &symbol1, const Symbol &symbol2) {
   const auto details1{symbol1.get<SubprogramDetails>()};
   const auto details2{symbol2.get<SubprogramDetails>()};
   if (details1.isFunction() != details2.isFunction()) {
     Say(symbol1, symbol2,
         details1.isFunction()
             ? "Module function '%s' was declared as a subroutine in the"
               " corresponding interface body"_err_en_US
             : "Module subroutine '%s' was declared as a function in the"
               " corresponding interface body"_err_en_US);
     return;
   }
   const auto &args1{details1.dummyArgs()};
   const auto &args2{details2.dummyArgs()};
   int nargs1{static_cast<int>(args1.size())};
   int nargs2{static_cast<int>(args2.size())};
   if (nargs1 != nargs2) {
     Say(symbol1, symbol2,
         "Module subprogram '%s' has %d args but the corresponding interface"
         " body has %d"_err_en_US,
         nargs1, nargs2);
     return;
   }
   bool nonRecursive1{symbol1.attrs().test(Attr::NON_RECURSIVE)};
   if (nonRecursive1 != symbol2.attrs().test(Attr::NON_RECURSIVE)) { // C1551
     Say(symbol1, symbol2,
         nonRecursive1
             ? "Module subprogram '%s' has NON_RECURSIVE prefix but"
               " the corresponding interface body does not"_err_en_US
             : "Module subprogram '%s' does not have NON_RECURSIVE prefix but "
               "the corresponding interface body does"_err_en_US);
   }
   MaybeExpr bindName1{details1.bindName()};
   MaybeExpr bindName2{details2.bindName()};
   if (bindName1.has_value() != bindName2.has_value()) {
     Say(symbol1, symbol2,
         bindName1.has_value()
             ? "Module subprogram '%s' has a binding label but the corresponding"
               " interface body does not"_err_en_US
             : "Module subprogram '%s' does not have a binding label but the"
               " corresponding interface body does"_err_en_US);
   } else if (bindName1) {
     std::string string1{bindName1->AsFortran()};
     std::string string2{bindName2->AsFortran()};
     if (string1 != string2) {
       Say(symbol1, symbol2,
           "Module subprogram '%s' has binding label %s but the corresponding"
           " interface body has %s"_err_en_US,
           string1, string2);
     }
   }
   auto proc1{Procedure::Characterize(symbol1, context.intrinsics())};
   auto proc2{Procedure::Characterize(symbol2, context.intrinsics())};
   if (!proc1 || !proc2) {
     return;
   }
   if (proc1->functionResult && proc2->functionResult &&
       *proc1->functionResult != *proc2->functionResult) {
     Say(symbol1, symbol2,
         "Return type of function '%s' does not match return type of"
         " the corresponding interface body"_err_en_US);
   }
   for (int i{0}; i < nargs1; ++i) {
     const Symbol *arg1{args1[i]};
     const Symbol *arg2{args2[i]};
     if (arg1 && !arg2) {
       Say(symbol1, symbol2,
           "Dummy argument %2$d of '%1$s' is not an alternate return indicator"
           " but the corresponding argument in the interface body is"_err_en_US,
           i + 1);
     } else if (!arg1 && arg2) {
       Say(symbol1, symbol2,
           "Dummy argument %2$d of '%1$s' is an alternate return indicator but"
           " the corresponding argument in the interface body is not"_err_en_US,
           i + 1);
     } else if (arg1 && arg2) {
       SourceName name1{arg1->name()};
       SourceName name2{arg2->name()};
       if (name1 != name2) {
         Say(*arg1, *arg2,
             "Dummy argument name '%s' does not match corresponding name '%s'"
             " in interface body"_err_en_US,
             name2);
       } else {
         CheckDummyArg(
             *arg1, *arg2, proc1->dummyArguments[i], proc2->dummyArguments[i]);
       }
     }
   }
 }
 
 void SubprogramMatchHelper::CheckDummyArg(const Symbol &symbol1,
     const Symbol &symbol2, const DummyArgument &arg1,
     const DummyArgument &arg2) {
   std::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,
                        "Dummy argument '%s' is a data object; the corresponding"
                        " argument in the interface body is not"_err_en_US);
                  },
                  [&](const DummyProcedure &, const auto &) {
                    Say(symbol1, symbol2,
                        "Dummy argument '%s' is a procedure; the corresponding"
                        " argument in the interface body is not"_err_en_US);
                  },
                  [&](const auto &, const auto &) {
                    llvm_unreachable("Dummy arguments are not data objects or"
                                     "procedures");
                  },
              },
       arg1.u, arg2.u);
 }
 
 void SubprogramMatchHelper::CheckDummyDataObject(const Symbol &symbol1,
     const Symbol &symbol2, const DummyDataObject &obj1,
     const DummyDataObject &obj2) {
   if (!CheckSameIntent(symbol1, symbol2, obj1.intent, obj2.intent)) {
   } else if (!CheckSameAttrs(symbol1, symbol2, obj1.attrs, obj2.attrs)) {
   } else if (obj1.type.type() != obj2.type.type()) {
     Say(symbol1, symbol2,
         "Dummy argument '%s' has type %s; the corresponding argument in the"
         " interface body has type %s"_err_en_US,
         obj1.type.type().AsFortran(), obj2.type.type().AsFortran());
   } else if (!ShapesAreCompatible(obj1, obj2)) {
     Say(symbol1, symbol2,
         "The shape of dummy argument '%s' does not match the shape of the"
         " corresponding argument in the interface body"_err_en_US);
   }
   // TODO: coshape
 }
 
 void SubprogramMatchHelper::CheckDummyProcedure(const Symbol &symbol1,
     const Symbol &symbol2, const DummyProcedure &proc1,
     const DummyProcedure &proc2) {
   if (!CheckSameIntent(symbol1, symbol2, proc1.intent, proc2.intent)) {
   } else if (!CheckSameAttrs(symbol1, symbol2, proc1.attrs, proc2.attrs)) {
   } else if (proc1 != proc2) {
     Say(symbol1, symbol2,
         "Dummy procedure '%s' does not match the corresponding argument in"
         " the interface body"_err_en_US);
   }
 }
 
 bool SubprogramMatchHelper::CheckSameIntent(const Symbol &symbol1,
     const Symbol &symbol2, common::Intent intent1, common::Intent intent2) {
   if (intent1 == intent2) {
     return true;
   } else {
     Say(symbol1, symbol2,
         "The intent of dummy argument '%s' does not match the intent"
         " of the corresponding argument in the interface body"_err_en_US);
     return false;
   }
 }
 
 // Report an error referring to first symbol with declaration of second symbol
 template <typename... A>
 void SubprogramMatchHelper::Say(const Symbol &symbol1, const Symbol &symbol2,
-    parser::MessageFixedText &&text, A &&... args) {
+    parser::MessageFixedText &&text, A &&...args) {
   auto &message{context.Say(symbol1.name(), std::move(text), symbol1.name(),
       std::forward<A>(args)...)};
   evaluate::AttachDeclaration(message, symbol2);
 }
 
 template <typename ATTRS>
 bool SubprogramMatchHelper::CheckSameAttrs(
     const Symbol &symbol1, const Symbol &symbol2, ATTRS attrs1, ATTRS attrs2) {
   if (attrs1 == attrs2) {
     return true;
   }
   attrs1.IterateOverMembers([&](auto attr) {
     if (!attrs2.test(attr)) {
       Say(symbol1, symbol2,
           "Dummy argument '%s' has the %s attribute; the corresponding"
           " argument in the interface body does not"_err_en_US,
           AsFortran(attr));
     }
   });
   attrs2.IterateOverMembers([&](auto attr) {
     if (!attrs1.test(attr)) {
       Say(symbol1, symbol2,
           "Dummy argument '%s' does not have the %s attribute; the"
           " corresponding argument in the interface body does"_err_en_US,
           AsFortran(attr));
     }
   });
   return false;
 }
 
 bool SubprogramMatchHelper::ShapesAreCompatible(
     const DummyDataObject &obj1, const DummyDataObject &obj2) {
   return evaluate::characteristics::ShapesAreCompatible(
       FoldShape(obj1.type.shape()), FoldShape(obj2.type.shape()));
 }
 
 evaluate::Shape SubprogramMatchHelper::FoldShape(const evaluate::Shape &shape) {
   evaluate::Shape result;
   for (const auto &extent : shape) {
     result.emplace_back(
         evaluate::Fold(context.foldingContext(), common::Clone(extent)));
   }
   return result;
 }
 
 void CheckDeclarations(SemanticsContext &context) {
   CheckHelper{context}.Check();
 }
 
 } // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/pointer-assignment.cpp b/flang/lib/Semantics/pointer-assignment.cpp
index 9adc998ec645..d97eedf37c12 100644
--- a/flang/lib/Semantics/pointer-assignment.cpp
+++ b/flang/lib/Semantics/pointer-assignment.cpp
@@ -1,465 +1,465 @@
 //===-- lib/Semantics/pointer-assignment.cpp ------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "pointer-assignment.h"
 #include "flang/Common/idioms.h"
 #include "flang/Common/restorer.h"
 #include "flang/Evaluate/characteristics.h"
 #include "flang/Evaluate/expression.h"
 #include "flang/Evaluate/fold.h"
 #include "flang/Evaluate/tools.h"
 #include "flang/Parser/message.h"
 #include "flang/Parser/parse-tree-visitor.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
 #include "llvm/Support/raw_ostream.h"
 #include <optional>
 #include <set>
 #include <string>
 #include <type_traits>
 
 // Semantic checks for pointer assignment.
 
 namespace Fortran::semantics {
 
 using namespace parser::literals;
 using evaluate::characteristics::DummyDataObject;
 using evaluate::characteristics::FunctionResult;
 using evaluate::characteristics::Procedure;
 using evaluate::characteristics::TypeAndShape;
 using parser::MessageFixedText;
 using parser::MessageFormattedText;
 
 class PointerAssignmentChecker {
 public:
   PointerAssignmentChecker(evaluate::FoldingContext &context,
       parser::CharBlock source, const std::string &description)
       : context_{context}, source_{source}, description_{description} {}
   PointerAssignmentChecker(evaluate::FoldingContext &context, const Symbol &lhs)
       : context_{context}, source_{lhs.name()},
         description_{"pointer '"s + lhs.name().ToString() + '\''}, lhs_{&lhs},
         procedure_{Procedure::Characterize(lhs, context.intrinsics())} {
     set_lhsType(TypeAndShape::Characterize(lhs, context));
     set_isContiguous(lhs.attrs().test(Attr::CONTIGUOUS));
     set_isVolatile(lhs.attrs().test(Attr::VOLATILE));
   }
   PointerAssignmentChecker &set_lhsType(std::optional<TypeAndShape> &&);
   PointerAssignmentChecker &set_isContiguous(bool);
   PointerAssignmentChecker &set_isVolatile(bool);
   PointerAssignmentChecker &set_isBoundsRemapping(bool);
   bool Check(const SomeExpr &);
 
 private:
   template <typename T> bool Check(const T &);
   template <typename T> bool Check(const evaluate::Expr<T> &);
   template <typename T> bool Check(const evaluate::FunctionRef<T> &);
   template <typename T> bool Check(const evaluate::Designator<T> &);
   bool Check(const evaluate::NullPointer &);
   bool Check(const evaluate::ProcedureDesignator &);
   bool Check(const evaluate::ProcedureRef &);
   // Target is a procedure
   bool Check(
       parser::CharBlock rhsName, bool isCall, const Procedure * = nullptr);
   bool LhsOkForUnlimitedPoly() const;
   template <typename... A> parser::Message *Say(A &&...);
 
   evaluate::FoldingContext &context_;
   const parser::CharBlock source_;
   const std::string description_;
   const Symbol *lhs_{nullptr};
   std::optional<TypeAndShape> lhsType_;
   std::optional<Procedure> procedure_;
   bool isContiguous_{false};
   bool isVolatile_{false};
   bool isBoundsRemapping_{false};
 };
 
 PointerAssignmentChecker &PointerAssignmentChecker::set_lhsType(
     std::optional<TypeAndShape> &&lhsType) {
   lhsType_ = std::move(lhsType);
   return *this;
 }
 
 PointerAssignmentChecker &PointerAssignmentChecker::set_isContiguous(
     bool isContiguous) {
   isContiguous_ = isContiguous;
   return *this;
 }
 
 PointerAssignmentChecker &PointerAssignmentChecker::set_isVolatile(
     bool isVolatile) {
   isVolatile_ = isVolatile;
   return *this;
 }
 
 PointerAssignmentChecker &PointerAssignmentChecker::set_isBoundsRemapping(
     bool isBoundsRemapping) {
   isBoundsRemapping_ = isBoundsRemapping;
   return *this;
 }
 
 template <typename T> bool PointerAssignmentChecker::Check(const T &) {
   // Catch-all case for really bad target expression
   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);
 }
 
 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);
   }
 }
 
 bool PointerAssignmentChecker::Check(const evaluate::NullPointer &) {
   return true; // P => NULL() without MOLD=; always OK
 }
 
 template <typename T>
 bool PointerAssignmentChecker::Check(const evaluate::FunctionRef<T> &f) {
   std::string funcName;
   const auto *symbol{f.proc().GetSymbol()};
   if (symbol) {
     funcName = symbol->name().ToString();
   } else if (const auto *intrinsic{f.proc().GetSpecificIntrinsic()}) {
     funcName = intrinsic->name;
   }
   auto proc{Procedure::Characterize(f.proc(), context_.intrinsics())};
   if (!proc) {
     return false;
   }
   std::optional<MessageFixedText> msg;
   const auto &funcResult{proc->functionResult}; // C1025
   if (!funcResult) {
     msg = "%s is associated with the non-existent result of reference to"
           " procedure"_err_en_US;
   } else if (procedure_) {
     // Shouldn't be here in this function unless lhs is an object pointer.
     msg = "Procedure %s is associated with the result of a reference to"
           " function '%s' that does not return a procedure pointer"_err_en_US;
   } else if (funcResult->IsProcedurePointer()) {
     msg = "Object %s is associated with the result of a reference to"
           " function '%s' that is a procedure pointer"_err_en_US;
   } else if (!funcResult->attrs.test(FunctionResult::Attr::Pointer)) {
     msg = "%s is associated with the result of a reference to function '%s'"
           " that is a not a pointer"_err_en_US;
   } else if (isContiguous_ &&
       !funcResult->attrs.test(FunctionResult::Attr::Contiguous)) {
     msg = "CONTIGUOUS %s is associated with the result of reference to"
           " function '%s' that is not contiguous"_err_en_US;
   } else if (lhsType_) {
     const auto *frTypeAndShape{funcResult->GetTypeAndShape()};
     CHECK(frTypeAndShape);
     if (!lhsType_->IsCompatibleWith(context_.messages(), *frTypeAndShape)) {
       msg = "%s is associated with the result of a reference to function '%s'"
             " whose pointer result has an incompatible type or shape"_err_en_US;
     }
   }
   if (msg) {
     auto restorer{common::ScopedSet(lhs_, symbol)};
     Say(*msg, description_, funcName);
     return false;
   }
   return true;
 }
 
 template <typename T>
 bool PointerAssignmentChecker::Check(const evaluate::Designator<T> &d) {
   const Symbol *last{d.GetLastSymbol()};
   const Symbol *base{d.GetBaseObject().symbol()};
   if (!last || !base) {
     // P => "character literal"(1:3)
     context_.messages().Say("Pointer target is not a named entity"_err_en_US);
     return false;
   }
   std::optional<std::variant<MessageFixedText, MessageFormattedText>> msg;
   if (procedure_) {
     // Shouldn't be here in this function unless lhs is an object pointer.
     msg = "In assignment to procedure %s, the target is not a procedure or"
           " procedure pointer"_err_en_US;
   } else if (!evaluate::GetLastTarget(GetSymbolVector(d))) { // C1025
     msg = "In assignment to object %s, the target '%s' is not an object with"
           " POINTER or TARGET attributes"_err_en_US;
   } else if (auto rhsType{TypeAndShape::Characterize(d, context_)}) {
     if (!lhsType_) {
       msg = "%s associated with object '%s' with incompatible type or"
             " shape"_err_en_US;
     } else if (rhsType->corank() > 0 &&
         (isVolatile_ != last->attrs().test(Attr::VOLATILE))) { // C1020
       // TODO: what if A is VOLATILE in A%B%C?  need a better test here
       if (isVolatile_) {
         msg = "Pointer may not be VOLATILE when target is a"
               " non-VOLATILE coarray"_err_en_US;
       } else {
         msg = "Pointer must be VOLATILE when target is a"
               " VOLATILE coarray"_err_en_US;
       }
     } else if (rhsType->type().IsUnlimitedPolymorphic()) {
       if (!LhsOkForUnlimitedPoly()) {
         msg = "Pointer type must be unlimited polymorphic or non-extensible"
               " derived type when target is unlimited polymorphic"_err_en_US;
       }
     } else {
       if (!lhsType_->type().IsTypeCompatibleWith(rhsType->type())) {
         msg = MessageFormattedText{
             "Target type %s is not compatible with pointer type %s"_err_en_US,
             rhsType->type().AsFortran(), lhsType_->type().AsFortran()};
 
       } else if (!isBoundsRemapping_) {
         std::size_t lhsRank{lhsType_->shape().size()};
         std::size_t rhsRank{rhsType->shape().size()};
         if (lhsRank != rhsRank) {
           msg = MessageFormattedText{
               "Pointer has rank %d but target has rank %d"_err_en_US, lhsRank,
               rhsRank};
         }
       }
     }
   }
   if (msg) {
     auto restorer{common::ScopedSet(lhs_, last)};
     if (auto *m{std::get_if<MessageFixedText>(&*msg)}) {
       std::string buf;
       llvm::raw_string_ostream ss{buf};
       d.AsFortran(ss);
       Say(*m, description_, ss.str());
     } else {
       Say(std::get<MessageFormattedText>(*msg));
     }
     return false;
   }
   return true;
 }
 
 // Compare procedure characteristics for equality except that lhs may be
 // Pure or Elemental when rhs is not.
 static bool CharacteristicsMatch(const Procedure &lhs, const Procedure &rhs) {
   using Attr = Procedure::Attr;
   auto lhsAttrs{rhs.attrs};
   lhsAttrs.set(
       Attr::Pure, lhs.attrs.test(Attr::Pure) | rhs.attrs.test(Attr::Pure));
   lhsAttrs.set(Attr::Elemental,
       lhs.attrs.test(Attr::Elemental) | rhs.attrs.test(Attr::Elemental));
   return lhsAttrs == rhs.attrs && lhs.functionResult == rhs.functionResult &&
       lhs.dummyArguments == rhs.dummyArguments;
 }
 
 // Common handling for procedure pointer right-hand sides
 bool PointerAssignmentChecker::Check(
     parser::CharBlock rhsName, bool isCall, const Procedure *rhsProcedure) {
   std::optional<MessageFixedText> msg;
   if (!procedure_) {
     msg = "In assignment to object %s, the target '%s' is a procedure"
           " designator"_err_en_US;
   } else if (!rhsProcedure) {
     msg = "In assignment to procedure %s, the characteristics of the target"
           " procedure '%s' could not be determined"_err_en_US;
   } else if (CharacteristicsMatch(*procedure_, *rhsProcedure)) {
     // OK
   } else if (isCall) {
     msg = "Procedure %s associated with result of reference to function '%s'"
           " that is an incompatible procedure pointer"_err_en_US;
   } else if (procedure_->IsPure() && !rhsProcedure->IsPure()) {
     msg = "PURE procedure %s may not be associated with non-PURE"
           " procedure designator '%s'"_err_en_US;
   } else if (procedure_->IsElemental() && !rhsProcedure->IsElemental()) {
     msg = "ELEMENTAL procedure %s may not be associated with non-ELEMENTAL"
           " procedure designator '%s'"_err_en_US;
   } else if (procedure_->IsFunction() && !rhsProcedure->IsFunction()) {
     msg = "Function %s may not be associated with subroutine"
           " designator '%s'"_err_en_US;
   } else if (!procedure_->IsFunction() && rhsProcedure->IsFunction()) {
     msg = "Subroutine %s may not be associated with function"
           " designator '%s'"_err_en_US;
   } else if (procedure_->HasExplicitInterface() &&
       !rhsProcedure->HasExplicitInterface()) {
     msg = "Procedure %s with explicit interface may not be associated with"
           " procedure designator '%s' with implicit interface"_err_en_US;
   } else if (!procedure_->HasExplicitInterface() &&
       rhsProcedure->HasExplicitInterface()) {
     msg = "Procedure %s with implicit interface may not be associated with"
           " procedure designator '%s' with explicit interface"_err_en_US;
   } else {
     msg = "Procedure %s associated with incompatible procedure"
           " designator '%s'"_err_en_US;
   }
   if (msg) {
     Say(std::move(*msg), description_, rhsName);
     return false;
   }
   return true;
 }
 
 bool PointerAssignmentChecker::Check(const evaluate::ProcedureDesignator &d) {
   if (auto chars{Procedure::Characterize(d, context_.intrinsics())}) {
     return Check(d.GetName(), false, &*chars);
   } else {
     return Check(d.GetName(), false);
   }
 }
 
 bool PointerAssignmentChecker::Check(const evaluate::ProcedureRef &ref) {
   const Procedure *procedure{nullptr};
   auto chars{Procedure::Characterize(ref, context_.intrinsics())};
   if (chars) {
     procedure = &*chars;
     if (chars->functionResult) {
       if (const auto *proc{chars->functionResult->IsProcedurePointer()}) {
         procedure = proc;
       }
     }
   }
   return Check(ref.proc().GetName(), true, procedure);
 }
 
 // The target can be unlimited polymorphic if the pointer is, or if it is
 // a non-extensible derived type.
 bool PointerAssignmentChecker::LhsOkForUnlimitedPoly() const {
   const auto &type{lhsType_->type()};
   if (type.category() != TypeCategory::Derived || type.IsAssumedType()) {
     return false;
   } else if (type.IsUnlimitedPolymorphic()) {
     return true;
   } else {
     return !IsExtensibleType(&type.GetDerivedTypeSpec());
   }
 }
 
 template <typename... A>
-parser::Message *PointerAssignmentChecker::Say(A &&... x) {
+parser::Message *PointerAssignmentChecker::Say(A &&...x) {
   auto *msg{context_.messages().Say(std::forward<A>(x)...)};
   if (lhs_) {
     return evaluate::AttachDeclaration(msg, *lhs_);
   } else if (!source_.empty()) {
     msg->Attach(source_, "Declaration of %s"_en_US, description_);
   }
   return msg;
 }
 
 // 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(
       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) {
               lhsSizeExpr = std::move(lhsSizeExpr) *
                   (common::Clone(bound.second) - common::Clone(bound.first) +
                       evaluate::ExtentExpr{1});
             }
             if (std::optional<std::int64_t> lhsSize{evaluate::ToInt64(
                     evaluate::Fold(context, std::move(lhsSizeExpr)))}) {
               if (auto shape{evaluate::GetShape(context, rhs)}) {
                 if (std::optional<std::int64_t> rhsSize{
                         evaluate::ToInt64(evaluate::Fold(
                             context, evaluate::GetSize(std::move(*shape))))}) {
                   if (*lhsSize > *rhsSize) {
                     messages.Say(
                         "Pointer bounds require %d elements but target has"
                         " only %d"_err_en_US,
                         *lhsSize, *rhsSize); // 10.2.2.3(9)
                   }
                 }
               }
             }
             return bounds.size();
           },
           [](const auto &) -> std::size_t {
             DIE("not valid for pointer assignment");
           },
       },
       assignment.u)};
   if (numBounds > 0) {
     if (lhs.Rank() != static_cast<int>(numBounds)) {
       messages.Say("Pointer '%s' has rank %d but the number of bounds specified"
                    " is %d"_err_en_US,
           lhs.AsFortran(), lhs.Rank(), numBounds); // C1018
     }
   }
   if (isBoundsRemapping && rhs.Rank() != 1 &&
       !evaluate::IsSimplyContiguous(rhs, context.intrinsics())) {
     messages.Say("Pointer bounds remapping target must have rank 1 or be"
                  " simply contiguous"_err_en_US); // 10.2.2.3(9)
   }
   return isBoundsRemapping;
 }
 
 bool CheckPointerAssignment(
     evaluate::FoldingContext &context, const evaluate::Assignment &assignment) {
   return CheckPointerAssignment(context, assignment.lhs, assignment.rhs,
       CheckPointerBounds(context, assignment));
 }
 
 bool CheckPointerAssignment(evaluate::FoldingContext &context,
     const SomeExpr &lhs, const SomeExpr &rhs, bool isBoundsRemapping) {
   const Symbol *pointer{GetLastSymbol(lhs)};
   if (!pointer) {
     return false; // error was reported
   }
   if (!IsPointer(*pointer)) {
     evaluate::SayWithDeclaration(context.messages(), *pointer,
         "'%s' is not a pointer"_err_en_US, pointer->name());
     return false;
   }
   if (pointer->has<ProcEntityDetails>() && evaluate::ExtractCoarrayRef(lhs)) {
     context.messages().Say( // C1027
         "Procedure pointer may not be a coindexed object"_err_en_US);
     return false;
   }
   return PointerAssignmentChecker{context, *pointer}
       .set_isBoundsRemapping(isBoundsRemapping)
       .Check(rhs);
 }
 
 bool CheckPointerAssignment(
     evaluate::FoldingContext &context, const Symbol &lhs, const SomeExpr &rhs) {
   CHECK(IsPointer(lhs));
   return PointerAssignmentChecker{context, lhs}.Check(rhs);
 }
 
 bool CheckPointerAssignment(evaluate::FoldingContext &context,
     parser::CharBlock source, const std::string &description,
     const DummyDataObject &lhs, const SomeExpr &rhs) {
   return PointerAssignmentChecker{context, source, description}
       .set_lhsType(common::Clone(lhs.type))
       .set_isContiguous(lhs.attrs.test(DummyDataObject::Attr::Contiguous))
       .set_isVolatile(lhs.attrs.test(DummyDataObject::Attr::Volatile))
       .Check(rhs);
 }
 
 bool CheckInitialTarget(evaluate::FoldingContext &context,
     const SomeExpr &pointer, const SomeExpr &init) {
   return evaluate::IsInitialDataTarget(init, &context.messages()) &&
       CheckPointerAssignment(context, pointer, init);
 }
 
 } // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/resolve-names.cpp b/flang/lib/Semantics/resolve-names.cpp
index b245ef91deaa..ad93d01b2a1a 100644
--- a/flang/lib/Semantics/resolve-names.cpp
+++ b/flang/lib/Semantics/resolve-names.cpp
@@ -1,6472 +1,6472 @@
 //===-- lib/Semantics/resolve-names.cpp -----------------------------------===//
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "resolve-names.h"
 #include "assignment.h"
 #include "mod-file.h"
 #include "pointer-assignment.h"
 #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/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"
 #include "flang/Parser/parse-tree-visitor.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Parser/tools.h"
 #include "flang/Semantics/attr.h"
 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/scope.h"
 #include "flang/Semantics/semantics.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
 #include "flang/Semantics/type.h"
 #include "llvm/Support/raw_ostream.h"
 #include <list>
 #include <map>
 #include <set>
 #include <stack>
 
 namespace Fortran::semantics {
 
 using namespace parser::literals;
 
 template <typename T> using Indirection = common::Indirection<T>;
 using Message = parser::Message;
 using Messages = parser::Messages;
 using MessageFixedText = parser::MessageFixedText;
 using MessageFormattedText = parser::MessageFormattedText;
 
 class ResolveNamesVisitor;
 
 // ImplicitRules maps initial character of identifier to the DeclTypeSpec
 // representing the implicit type; std::nullopt if none.
 // It also records the presence of IMPLICIT NONE statements.
 // When inheritFromParent is set, defaults come from the parent rules.
 class ImplicitRules {
 public:
   ImplicitRules(SemanticsContext &context, ImplicitRules *parent)
       : parent_{parent}, context_{context} {
     inheritFromParent_ = parent != nullptr;
   }
   bool isImplicitNoneType() const;
   bool isImplicitNoneExternal() const;
   void set_isImplicitNoneType(bool x) { isImplicitNoneType_ = x; }
   void set_isImplicitNoneExternal(bool x) { isImplicitNoneExternal_ = x; }
   void set_inheritFromParent(bool x) { inheritFromParent_ = x; }
   // Get the implicit type for identifiers starting with ch. May be null.
   const DeclTypeSpec *GetType(char ch) const;
   // Record the implicit type for the range of characters [fromLetter,
   // toLetter].
   void SetTypeMapping(const DeclTypeSpec &type, parser::Location fromLetter,
       parser::Location toLetter);
 
 private:
   static char Incr(char ch);
 
   ImplicitRules *parent_;
   SemanticsContext &context_;
   bool inheritFromParent_{false}; // look in parent if not specified here
   bool isImplicitNoneType_{
       context_.IsEnabled(common::LanguageFeature::ImplicitNoneTypeAlways)};
   bool isImplicitNoneExternal_{false};
   // map_ contains the mapping between letters and types that were defined
   // by the IMPLICIT statements of the related scope. It does not contain
   // the default Fortran mappings nor the mapping defined in parents.
   std::map<char, common::Reference<const DeclTypeSpec>> map_;
 
   friend llvm::raw_ostream &operator<<(
       llvm::raw_ostream &, const ImplicitRules &);
   friend void ShowImplicitRule(
       llvm::raw_ostream &, const ImplicitRules &, char);
 };
 
 // scope -> implicit rules for that scope
 using ImplicitRulesMap = std::map<const Scope *, ImplicitRules>;
 
 // Track statement source locations and save messages.
 class MessageHandler {
 public:
   MessageHandler() { DIE("MessageHandler: default-constructed"); }
   explicit MessageHandler(SemanticsContext &c) : context_{&c} {}
   Messages &messages() { return context_->messages(); };
   const std::optional<SourceName> &currStmtSource() {
     return context_->location();
   }
   void set_currStmtSource(const std::optional<SourceName> &source) {
     context_->set_location(source);
   }
 
   // Emit a message associated with the current statement source.
   Message &Say(MessageFixedText &&);
   Message &Say(MessageFormattedText &&);
   // Emit a message about a SourceName
   Message &Say(const SourceName &, MessageFixedText &&);
   // Emit a formatted message associated with a source location.
   template <typename... A>
-  Message &Say(const SourceName &source, MessageFixedText &&msg, A &&... args) {
+  Message &Say(const SourceName &source, MessageFixedText &&msg, A &&...args) {
     return context_->Say(source, std::move(msg), std::forward<A>(args)...);
   }
 
 private:
   SemanticsContext *context_;
 };
 
 // Inheritance graph for the parse tree visitation classes that follow:
 //   BaseVisitor
 //   + AttrsVisitor
 //   | + DeclTypeSpecVisitor
 //   |   + ImplicitRulesVisitor
 //   |     + ScopeHandler -----------+--+
 //   |       + ModuleVisitor ========|==+
 //   |       + InterfaceVisitor      |  |
 //   |       +-+ SubprogramVisitor ==|==+
 //   + ArraySpecVisitor              |  |
 //     + DeclarationVisitor <--------+  |
 //       + ConstructVisitor             |
 //         + ResolveNamesVisitor <------+
 
 class BaseVisitor {
 public:
   BaseVisitor() { DIE("BaseVisitor: default-constructed"); }
   BaseVisitor(
       SemanticsContext &c, ResolveNamesVisitor &v, ImplicitRulesMap &rules)
       : implicitRulesMap_{&rules}, this_{&v}, context_{&c}, messageHandler_{c} {
   }
   template <typename T> void Walk(const T &);
 
   MessageHandler &messageHandler() { return messageHandler_; }
   const std::optional<SourceName> &currStmtSource() {
     return context_->location();
   }
   SemanticsContext &context() const { return *context_; }
   evaluate::FoldingContext &GetFoldingContext() const {
     return context_->foldingContext();
   }
   bool IsIntrinsic(const SourceName &name) const {
     return context_->intrinsics().IsIntrinsic(name.ToString());
   }
 
   // Make a placeholder symbol for a Name that otherwise wouldn't have one.
   // It is not in any scope and always has MiscDetails.
   void MakePlaceholder(const parser::Name &, MiscDetails::Kind);
 
   template <typename T> common::IfNoLvalue<T, T> FoldExpr(T &&expr) {
     return evaluate::Fold(GetFoldingContext(), std::move(expr));
   }
 
   template <typename T> MaybeExpr EvaluateExpr(const T &expr) {
     return FoldExpr(AnalyzeExpr(*context_, expr));
   }
 
   template <typename T>
   MaybeExpr EvaluateConvertedExpr(
       const Symbol &symbol, const T &expr, parser::CharBlock source) {
     if (context().HasError(symbol)) {
       return std::nullopt;
     }
     auto maybeExpr{AnalyzeExpr(*context_, expr)};
     if (!maybeExpr) {
       return std::nullopt;
     }
     auto exprType{maybeExpr->GetType()};
     auto converted{evaluate::ConvertToType(symbol, std::move(*maybeExpr))};
     if (!converted) {
       if (exprType) {
         Say(source,
             "Initialization expression could not be converted to declared type of '%s' from %s"_err_en_US,
             symbol.name(), exprType->AsFortran());
       } else {
         Say(source,
             "Initialization expression could not be converted to declared type of '%s'"_err_en_US,
             symbol.name());
       }
       return std::nullopt;
     }
     return FoldExpr(std::move(*converted));
   }
 
   template <typename T> MaybeIntExpr EvaluateIntExpr(const T &expr) {
     return semantics::EvaluateIntExpr(*context_, expr);
   }
 
   template <typename T>
   MaybeSubscriptIntExpr EvaluateSubscriptIntExpr(const T &expr) {
     if (MaybeIntExpr maybeIntExpr{EvaluateIntExpr(expr)}) {
       return FoldExpr(evaluate::ConvertToType<evaluate::SubscriptInteger>(
           std::move(*maybeIntExpr)));
     } else {
       return std::nullopt;
     }
   }
 
-  template <typename... A> Message &Say(A &&... args) {
+  template <typename... A> Message &Say(A &&...args) {
     return messageHandler_.Say(std::forward<A>(args)...);
   }
   template <typename... A>
   Message &Say(
-      const parser::Name &name, MessageFixedText &&text, const A &... args) {
+      const parser::Name &name, MessageFixedText &&text, const A &...args) {
     return messageHandler_.Say(name.source, std::move(text), args...);
   }
 
 protected:
   ImplicitRulesMap *implicitRulesMap_{nullptr};
 
 private:
   ResolveNamesVisitor *this_;
   SemanticsContext *context_;
   MessageHandler messageHandler_;
 };
 
 // Provide Post methods to collect attributes into a member variable.
 class AttrsVisitor : public virtual BaseVisitor {
 public:
   bool BeginAttrs(); // always returns true
   Attrs GetAttrs();
   Attrs EndAttrs();
   bool SetPassNameOn(Symbol &);
   bool SetBindNameOn(Symbol &);
   void Post(const parser::LanguageBindingSpec &);
   bool Pre(const parser::IntentSpec &);
   bool Pre(const parser::Pass &);
 
   bool CheckAndSet(Attr);
 
 // Simple case: encountering CLASSNAME causes ATTRNAME to be set.
 #define HANDLE_ATTR_CLASS(CLASSNAME, ATTRNAME) \
   bool Pre(const parser::CLASSNAME &) { \
     CheckAndSet(Attr::ATTRNAME); \
     return false; \
   }
   HANDLE_ATTR_CLASS(PrefixSpec::Elemental, ELEMENTAL)
   HANDLE_ATTR_CLASS(PrefixSpec::Impure, IMPURE)
   HANDLE_ATTR_CLASS(PrefixSpec::Module, MODULE)
   HANDLE_ATTR_CLASS(PrefixSpec::Non_Recursive, NON_RECURSIVE)
   HANDLE_ATTR_CLASS(PrefixSpec::Pure, PURE)
   HANDLE_ATTR_CLASS(PrefixSpec::Recursive, RECURSIVE)
   HANDLE_ATTR_CLASS(TypeAttrSpec::BindC, BIND_C)
   HANDLE_ATTR_CLASS(BindAttr::Deferred, DEFERRED)
   HANDLE_ATTR_CLASS(BindAttr::Non_Overridable, NON_OVERRIDABLE)
   HANDLE_ATTR_CLASS(Abstract, ABSTRACT)
   HANDLE_ATTR_CLASS(Allocatable, ALLOCATABLE)
   HANDLE_ATTR_CLASS(Asynchronous, ASYNCHRONOUS)
   HANDLE_ATTR_CLASS(Contiguous, CONTIGUOUS)
   HANDLE_ATTR_CLASS(External, EXTERNAL)
   HANDLE_ATTR_CLASS(Intrinsic, INTRINSIC)
   HANDLE_ATTR_CLASS(NoPass, NOPASS)
   HANDLE_ATTR_CLASS(Optional, OPTIONAL)
   HANDLE_ATTR_CLASS(Parameter, PARAMETER)
   HANDLE_ATTR_CLASS(Pointer, POINTER)
   HANDLE_ATTR_CLASS(Protected, PROTECTED)
   HANDLE_ATTR_CLASS(Save, SAVE)
   HANDLE_ATTR_CLASS(Target, TARGET)
   HANDLE_ATTR_CLASS(Value, VALUE)
   HANDLE_ATTR_CLASS(Volatile, VOLATILE)
 #undef HANDLE_ATTR_CLASS
 
 protected:
   std::optional<Attrs> attrs_;
 
   Attr AccessSpecToAttr(const parser::AccessSpec &x) {
     switch (x.v) {
     case parser::AccessSpec::Kind::Public:
       return Attr::PUBLIC;
     case parser::AccessSpec::Kind::Private:
       return Attr::PRIVATE;
     }
     llvm_unreachable("Switch covers all cases"); // suppress g++ warning
   }
   Attr IntentSpecToAttr(const parser::IntentSpec &x) {
     switch (x.v) {
     case parser::IntentSpec::Intent::In:
       return Attr::INTENT_IN;
     case parser::IntentSpec::Intent::Out:
       return Attr::INTENT_OUT;
     case parser::IntentSpec::Intent::InOut:
       return Attr::INTENT_INOUT;
     }
     llvm_unreachable("Switch covers all cases"); // suppress g++ warning
   }
 
 private:
   bool IsDuplicateAttr(Attr);
   bool HaveAttrConflict(Attr, Attr, Attr);
   bool IsConflictingAttr(Attr);
 
   MaybeExpr bindName_; // from BIND(C, NAME="...")
   std::optional<SourceName> passName_; // from PASS(...)
 };
 
 // Find and create types from declaration-type-spec nodes.
 class DeclTypeSpecVisitor : public AttrsVisitor {
 public:
   using AttrsVisitor::Post;
   using AttrsVisitor::Pre;
   void Post(const parser::IntrinsicTypeSpec::DoublePrecision &);
   void Post(const parser::IntrinsicTypeSpec::DoubleComplex &);
   void Post(const parser::DeclarationTypeSpec::ClassStar &);
   void Post(const parser::DeclarationTypeSpec::TypeStar &);
   bool Pre(const parser::TypeGuardStmt &);
   void Post(const parser::TypeGuardStmt &);
   void Post(const parser::TypeSpec &);
 
 protected:
   struct State {
     bool expectDeclTypeSpec{false}; // should see decl-type-spec only when true
     const DeclTypeSpec *declTypeSpec{nullptr};
     struct {
       DerivedTypeSpec *type{nullptr};
       DeclTypeSpec::Category category{DeclTypeSpec::TypeDerived};
     } derived;
     bool allowForwardReferenceToDerivedType{false};
   };
 
   bool allowForwardReferenceToDerivedType() const {
     return state_.allowForwardReferenceToDerivedType;
   }
   void set_allowForwardReferenceToDerivedType(bool yes) {
     state_.allowForwardReferenceToDerivedType = yes;
   }
 
   // Walk the parse tree of a type spec and return the DeclTypeSpec for it.
   template <typename T>
   const DeclTypeSpec *ProcessTypeSpec(const T &x, bool allowForward = false) {
     auto restorer{common::ScopedSet(state_, State{})};
     set_allowForwardReferenceToDerivedType(allowForward);
     BeginDeclTypeSpec();
     Walk(x);
     const auto *type{GetDeclTypeSpec()};
     EndDeclTypeSpec();
     return type;
   }
 
   const DeclTypeSpec *GetDeclTypeSpec();
   void BeginDeclTypeSpec();
   void EndDeclTypeSpec();
   void SetDeclTypeSpec(const DeclTypeSpec &);
   void SetDeclTypeSpecCategory(DeclTypeSpec::Category);
   DeclTypeSpec::Category GetDeclTypeSpecCategory() const {
     return state_.derived.category;
   }
   KindExpr GetKindParamExpr(
       TypeCategory, const std::optional<parser::KindSelector> &);
   void CheckForAbstractType(const Symbol &typeSymbol);
 
 private:
   State state_;
 
   void MakeNumericType(TypeCategory, int kind);
 };
 
 // Visit ImplicitStmt and related parse tree nodes and updates implicit rules.
 class ImplicitRulesVisitor : public DeclTypeSpecVisitor {
 public:
   using DeclTypeSpecVisitor::Post;
   using DeclTypeSpecVisitor::Pre;
   using ImplicitNoneNameSpec = parser::ImplicitStmt::ImplicitNoneNameSpec;
 
   void Post(const parser::ParameterStmt &);
   bool Pre(const parser::ImplicitStmt &);
   bool Pre(const parser::LetterSpec &);
   bool Pre(const parser::ImplicitSpec &);
   void Post(const parser::ImplicitSpec &);
 
   ImplicitRules &implicitRules() { return *implicitRules_; }
   const ImplicitRules &implicitRules() const { return *implicitRules_; }
   bool isImplicitNoneType() const {
     return implicitRules().isImplicitNoneType();
   }
   bool isImplicitNoneExternal() const {
     return implicitRules().isImplicitNoneExternal();
   }
 
 protected:
   void BeginScope(const Scope &);
   void SetScope(const Scope &);
 
 private:
   // implicit rules in effect for current scope
   ImplicitRules *implicitRules_{nullptr};
   std::optional<SourceName> prevImplicit_;
   std::optional<SourceName> prevImplicitNone_;
   std::optional<SourceName> prevImplicitNoneType_;
   std::optional<SourceName> prevParameterStmt_;
 
   bool HandleImplicitNone(const std::list<ImplicitNoneNameSpec> &nameSpecs);
 };
 
 // Track array specifications. They can occur in AttrSpec, EntityDecl,
 // ObjectDecl, DimensionStmt, CommonBlockObject, or BasedPointerStmt.
 // 1. INTEGER, DIMENSION(10) :: x
 // 2. INTEGER :: x(10)
 // 3. ALLOCATABLE :: x(:)
 // 4. DIMENSION :: x(10)
 // 5. COMMON x(10)
 // 6. BasedPointerStmt
 class ArraySpecVisitor : public virtual BaseVisitor {
 public:
   void Post(const parser::ArraySpec &);
   void Post(const parser::ComponentArraySpec &);
   void Post(const parser::CoarraySpec &);
   void Post(const parser::AttrSpec &) { PostAttrSpec(); }
   void Post(const parser::ComponentAttrSpec &) { PostAttrSpec(); }
 
 protected:
   const ArraySpec &arraySpec();
   const ArraySpec &coarraySpec();
   void BeginArraySpec();
   void EndArraySpec();
   void ClearArraySpec() { arraySpec_.clear(); }
   void ClearCoarraySpec() { coarraySpec_.clear(); }
 
 private:
   // arraySpec_/coarraySpec_ are populated from any ArraySpec/CoarraySpec
   ArraySpec arraySpec_;
   ArraySpec coarraySpec_;
   // When an ArraySpec is under an AttrSpec or ComponentAttrSpec, it is moved
   // into attrArraySpec_
   ArraySpec attrArraySpec_;
   ArraySpec attrCoarraySpec_;
 
   void PostAttrSpec();
 };
 
 // Manage a stack of Scopes
 class ScopeHandler : public ImplicitRulesVisitor {
 public:
   using ImplicitRulesVisitor::Post;
   using ImplicitRulesVisitor::Pre;
 
   Scope &currScope() { return DEREF(currScope_); }
   // The enclosing scope, skipping blocks and derived types.
   // TODO: Will return the scope of a FORALL or implied DO loop; is this ok?
   // If not, should call FindProgramUnitContaining() instead.
   Scope &InclusiveScope();
   // The enclosing scope, skipping derived types.
   Scope &NonDerivedTypeScope();
 
   // Create a new scope and push it on the scope stack.
   void PushScope(Scope::Kind kind, Symbol *symbol);
   void PushScope(Scope &scope);
   void PopScope();
   void SetScope(Scope &);
 
   template <typename T> bool Pre(const parser::Statement<T> &x) {
     messageHandler().set_currStmtSource(x.source);
     currScope_->AddSourceRange(x.source);
     return true;
   }
   template <typename T> void Post(const parser::Statement<T> &) {
     messageHandler().set_currStmtSource(std::nullopt);
   }
 
   // Special messages: already declared; referencing symbol's declaration;
   // about a type; two names & locations
   void SayAlreadyDeclared(const parser::Name &, Symbol &);
   void SayAlreadyDeclared(const SourceName &, Symbol &);
   void SayAlreadyDeclared(const SourceName &, const SourceName &);
   void SayWithReason(
       const parser::Name &, Symbol &, MessageFixedText &&, MessageFixedText &&);
   void SayWithDecl(const parser::Name &, Symbol &, MessageFixedText &&);
   void SayLocalMustBeVariable(const parser::Name &, Symbol &);
   void SayDerivedType(const SourceName &, MessageFixedText &&, const Scope &);
   void Say2(const SourceName &, MessageFixedText &&, const SourceName &,
       MessageFixedText &&);
   void Say2(
       const SourceName &, MessageFixedText &&, Symbol &, MessageFixedText &&);
   void Say2(
       const parser::Name &, MessageFixedText &&, Symbol &, MessageFixedText &&);
 
   // Search for symbol by name in current, parent derived type, and
   // containing scopes
   Symbol *FindSymbol(const parser::Name &);
   Symbol *FindSymbol(const Scope &, const parser::Name &);
   // Search for name only in scope, not in enclosing scopes.
   Symbol *FindInScope(const Scope &, const parser::Name &);
   Symbol *FindInScope(const Scope &, const SourceName &);
   // Search for name in a derived type scope and its parents.
   Symbol *FindInTypeOrParents(const Scope &, const parser::Name &);
   Symbol *FindInTypeOrParents(const parser::Name &);
   void EraseSymbol(const parser::Name &);
   void EraseSymbol(const Symbol &symbol) { currScope().erase(symbol.name()); }
   // Make a new symbol with the name and attrs of an existing one
   Symbol &CopySymbol(const SourceName &, const Symbol &);
 
   // Make symbols in the current or named scope
   Symbol &MakeSymbol(Scope &, const SourceName &, Attrs);
   Symbol &MakeSymbol(const SourceName &, Attrs = Attrs{});
   Symbol &MakeSymbol(const parser::Name &, Attrs = Attrs{});
 
   template <typename D>
   common::IfNoLvalue<Symbol &, D> MakeSymbol(
       const parser::Name &name, D &&details) {
     return MakeSymbol(name, Attrs{}, std::move(details));
   }
 
   template <typename D>
   common::IfNoLvalue<Symbol &, D> MakeSymbol(
       const parser::Name &name, const Attrs &attrs, D &&details) {
     return Resolve(name, MakeSymbol(name.source, attrs, std::move(details)));
   }
 
   template <typename D>
   common::IfNoLvalue<Symbol &, D> MakeSymbol(
       const SourceName &name, const Attrs &attrs, D &&details) {
     // Note: don't use FindSymbol here. If this is a derived type scope,
     // we want to detect whether the name is already declared as a component.
     auto *symbol{FindInScope(currScope(), name)};
     if (!symbol) {
       symbol = &MakeSymbol(name, attrs);
       symbol->set_details(std::move(details));
       return *symbol;
     }
     if constexpr (std::is_same_v<DerivedTypeDetails, D>) {
       if (auto *d{symbol->detailsIf<GenericDetails>()}) {
         if (!d->specific()) {
           // derived type with same name as a generic
           auto *derivedType{d->derivedType()};
           if (!derivedType) {
             derivedType =
                 &currScope().MakeSymbol(name, attrs, std::move(details));
             d->set_derivedType(*derivedType);
           } else {
             SayAlreadyDeclared(name, *derivedType);
           }
           return *derivedType;
         }
       }
     }
     if (symbol->CanReplaceDetails(details)) {
       // update the existing symbol
       symbol->attrs() |= attrs;
       symbol->set_details(std::move(details));
       return *symbol;
     } else if constexpr (std::is_same_v<UnknownDetails, D>) {
       symbol->attrs() |= attrs;
       return *symbol;
     } else {
       SayAlreadyDeclared(name, *symbol);
       // replace the old symbol with a new one with correct details
       EraseSymbol(*symbol);
       auto &result{MakeSymbol(name, attrs, std::move(details))};
       context().SetError(result);
       return result;
     }
   }
 
   void MakeExternal(Symbol &);
 
 protected:
   // Apply the implicit type rules to this symbol.
   void ApplyImplicitRules(Symbol &);
   const DeclTypeSpec *GetImplicitType(Symbol &);
   bool ConvertToObjectEntity(Symbol &);
   bool ConvertToProcEntity(Symbol &);
 
   const DeclTypeSpec &MakeNumericType(
       TypeCategory, const std::optional<parser::KindSelector> &);
   const DeclTypeSpec &MakeLogicalType(
       const std::optional<parser::KindSelector> &);
 
 private:
   Scope *currScope_{nullptr};
 };
 
 class ModuleVisitor : public virtual ScopeHandler {
 public:
   bool Pre(const parser::AccessStmt &);
   bool Pre(const parser::Only &);
   bool Pre(const parser::Rename::Names &);
   bool Pre(const parser::Rename::Operators &);
   bool Pre(const parser::UseStmt &);
   void Post(const parser::UseStmt &);
 
   void BeginModule(const parser::Name &, bool isSubmodule);
   bool BeginSubmodule(const parser::Name &, const parser::ParentIdentifier &);
   void ApplyDefaultAccess();
 
 private:
   // The default access spec for this module.
   Attr defaultAccess_{Attr::PUBLIC};
   // The location of the last AccessStmt without access-ids, if any.
   std::optional<SourceName> prevAccessStmt_;
   // The scope of the module during a UseStmt
   const Scope *useModuleScope_{nullptr};
 
   Symbol &SetAccess(const SourceName &, Attr attr, Symbol * = nullptr);
   // A rename in a USE statement: local => use
   struct SymbolRename {
     Symbol *local{nullptr};
     Symbol *use{nullptr};
   };
   // Record a use from useModuleScope_ of use Name/Symbol as local Name/Symbol
   SymbolRename AddUse(const SourceName &localName, const SourceName &useName);
   SymbolRename AddUse(const SourceName &, const SourceName &, Symbol *);
   void AddUse(const SourceName &, Symbol &localSymbol, const Symbol &useSymbol);
   void AddUse(const GenericSpecInfo &);
   Scope *FindModule(const parser::Name &, Scope *ancestor = nullptr);
 };
 
 class InterfaceVisitor : public virtual ScopeHandler {
 public:
   bool Pre(const parser::InterfaceStmt &);
   void Post(const parser::InterfaceStmt &);
   void Post(const parser::EndInterfaceStmt &);
   bool Pre(const parser::GenericSpec &);
   bool Pre(const parser::ProcedureStmt &);
   bool Pre(const parser::GenericStmt &);
   void Post(const parser::GenericStmt &);
 
   bool inInterfaceBlock() const;
   bool isGeneric() const;
   bool isAbstract() const;
 
 protected:
   GenericDetails &GetGenericDetails();
   // Add to generic the symbol for the subprogram with the same name
   void CheckGenericProcedures(Symbol &);
 
 private:
   // A new GenericInfo is pushed for each interface block and generic stmt
   struct GenericInfo {
     GenericInfo(bool isInterface, bool isAbstract = false)
         : isInterface{isInterface}, isAbstract{isAbstract} {}
     bool isInterface; // in interface block
     bool isAbstract; // in abstract interface block
     Symbol *symbol{nullptr}; // the generic symbol being defined
   };
   std::stack<GenericInfo> genericInfo_;
   const GenericInfo &GetGenericInfo() const { return genericInfo_.top(); }
   void SetGenericSymbol(Symbol &symbol) { genericInfo_.top().symbol = &symbol; }
 
   using ProcedureKind = parser::ProcedureStmt::Kind;
   // mapping of generic to its specific proc names and kinds
   std::multimap<Symbol *, std::pair<const parser::Name *, ProcedureKind>>
       specificProcs_;
 
   void AddSpecificProcs(const std::list<parser::Name> &, ProcedureKind);
   void ResolveSpecificsInGeneric(Symbol &generic);
 };
 
 class SubprogramVisitor : public virtual ScopeHandler, public InterfaceVisitor {
 public:
   bool HandleStmtFunction(const parser::StmtFunctionStmt &);
   bool Pre(const parser::SubroutineStmt &);
   void Post(const parser::SubroutineStmt &);
   bool Pre(const parser::FunctionStmt &);
   void Post(const parser::FunctionStmt &);
   bool Pre(const parser::EntryStmt &);
   void Post(const parser::EntryStmt &);
   bool Pre(const parser::InterfaceBody::Subroutine &);
   void Post(const parser::InterfaceBody::Subroutine &);
   bool Pre(const parser::InterfaceBody::Function &);
   void Post(const parser::InterfaceBody::Function &);
   bool Pre(const parser::Suffix &);
   bool Pre(const parser::PrefixSpec &);
   void Post(const parser::ImplicitPart &);
 
   bool BeginSubprogram(
       const parser::Name &, Symbol::Flag, bool hasModulePrefix = false);
   bool BeginMpSubprogram(const parser::Name &);
   void PushBlockDataScope(const parser::Name &);
   void EndSubprogram();
 
 protected:
   // Set when we see a stmt function that is really an array element assignment
   bool badStmtFuncFound_{false};
   bool inExecutionPart_{false};
 
 private:
   // Info about the current function: parse tree of the type in the PrefixSpec;
   // name and symbol of the function result from the Suffix; source location.
   struct {
     const parser::DeclarationTypeSpec *parsedType{nullptr};
     const parser::Name *resultName{nullptr};
     Symbol *resultSymbol{nullptr};
     std::optional<SourceName> source;
   } funcInfo_;
 
   // Create a subprogram symbol in the current scope and push a new scope.
   void CheckExtantExternal(const parser::Name &, Symbol::Flag);
   Symbol &PushSubprogramScope(const parser::Name &, Symbol::Flag);
   Symbol *GetSpecificFromGeneric(const parser::Name &);
   SubprogramDetails &PostSubprogramStmt(const parser::Name &);
 };
 
 class DeclarationVisitor : public ArraySpecVisitor,
                            public virtual ScopeHandler {
 public:
   using ArraySpecVisitor::Post;
   using ScopeHandler::Post;
   using ScopeHandler::Pre;
 
   bool Pre(const parser::Initialization &);
   void Post(const parser::EntityDecl &);
   void Post(const parser::ObjectDecl &);
   void Post(const parser::PointerDecl &);
   bool Pre(const parser::BindStmt &) { return BeginAttrs(); }
   void Post(const parser::BindStmt &) { EndAttrs(); }
   bool Pre(const parser::BindEntity &);
   bool Pre(const parser::NamedConstantDef &);
   bool Pre(const parser::NamedConstant &);
   void Post(const parser::EnumDef &);
   bool Pre(const parser::Enumerator &);
   bool Pre(const parser::AccessSpec &);
   bool Pre(const parser::AsynchronousStmt &);
   bool Pre(const parser::ContiguousStmt &);
   bool Pre(const parser::ExternalStmt &);
   bool Pre(const parser::IntentStmt &);
   bool Pre(const parser::IntrinsicStmt &);
   bool Pre(const parser::OptionalStmt &);
   bool Pre(const parser::ProtectedStmt &);
   bool Pre(const parser::ValueStmt &);
   bool Pre(const parser::VolatileStmt &);
   bool Pre(const parser::AllocatableStmt &) {
     objectDeclAttr_ = Attr::ALLOCATABLE;
     return true;
   }
   void Post(const parser::AllocatableStmt &) { objectDeclAttr_ = std::nullopt; }
   bool Pre(const parser::TargetStmt &) {
     objectDeclAttr_ = Attr::TARGET;
     return true;
   }
   void Post(const parser::TargetStmt &) { objectDeclAttr_ = std::nullopt; }
   void Post(const parser::DimensionStmt::Declaration &);
   void Post(const parser::CodimensionDecl &);
   bool Pre(const parser::TypeDeclarationStmt &) { return BeginDecl(); }
   void Post(const parser::TypeDeclarationStmt &);
   void Post(const parser::IntegerTypeSpec &);
   void Post(const parser::IntrinsicTypeSpec::Real &);
   void Post(const parser::IntrinsicTypeSpec::Complex &);
   void Post(const parser::IntrinsicTypeSpec::Logical &);
   void Post(const parser::IntrinsicTypeSpec::Character &);
   void Post(const parser::CharSelector::LengthAndKind &);
   void Post(const parser::CharLength &);
   void Post(const parser::LengthSelector &);
   bool Pre(const parser::KindParam &);
   bool Pre(const parser::DeclarationTypeSpec::Type &);
   void Post(const parser::DeclarationTypeSpec::Type &);
   bool Pre(const parser::DeclarationTypeSpec::Class &);
   void Post(const parser::DeclarationTypeSpec::Class &);
   bool Pre(const parser::DeclarationTypeSpec::Record &);
   void Post(const parser::DerivedTypeSpec &);
   bool Pre(const parser::DerivedTypeDef &);
   bool Pre(const parser::DerivedTypeStmt &);
   void Post(const parser::DerivedTypeStmt &);
   bool Pre(const parser::TypeParamDefStmt &) { return BeginDecl(); }
   void Post(const parser::TypeParamDefStmt &);
   bool Pre(const parser::TypeAttrSpec::Extends &);
   bool Pre(const parser::PrivateStmt &);
   bool Pre(const parser::SequenceStmt &);
   bool Pre(const parser::ComponentDefStmt &) { return BeginDecl(); }
   void Post(const parser::ComponentDefStmt &) { EndDecl(); }
   void Post(const parser::ComponentDecl &);
   bool Pre(const parser::ProcedureDeclarationStmt &);
   void Post(const parser::ProcedureDeclarationStmt &);
   bool Pre(const parser::DataComponentDefStmt &); // returns false
   bool Pre(const parser::ProcComponentDefStmt &);
   void Post(const parser::ProcComponentDefStmt &);
   bool Pre(const parser::ProcPointerInit &);
   void Post(const parser::ProcInterface &);
   void Post(const parser::ProcDecl &);
   bool Pre(const parser::TypeBoundProcedurePart &);
   void Post(const parser::TypeBoundProcedurePart &);
   void Post(const parser::ContainsStmt &);
   bool Pre(const parser::TypeBoundProcBinding &) { return BeginAttrs(); }
   void Post(const parser::TypeBoundProcBinding &) { EndAttrs(); }
   void Post(const parser::TypeBoundProcedureStmt::WithoutInterface &);
   void Post(const parser::TypeBoundProcedureStmt::WithInterface &);
   void Post(const parser::FinalProcedureStmt &);
   bool Pre(const parser::TypeBoundGenericStmt &);
   bool Pre(const parser::AllocateStmt &);
   void Post(const parser::AllocateStmt &);
   bool Pre(const parser::StructureConstructor &);
   bool Pre(const parser::NamelistStmt::Group &);
   bool Pre(const parser::IoControlSpec &);
   bool Pre(const parser::CommonStmt::Block &);
   void Post(const parser::CommonStmt::Block &);
   bool Pre(const parser::CommonBlockObject &);
   void Post(const parser::CommonBlockObject &);
   bool Pre(const parser::EquivalenceStmt &);
   bool Pre(const parser::SaveStmt &);
   bool Pre(const parser::BasedPointerStmt &);
 
   void PointerInitialization(
       const parser::Name &, const parser::InitialDataTarget &);
   void PointerInitialization(
       const parser::Name &, const parser::ProcPointerInit &);
   void NonPointerInitialization(
       const parser::Name &, const parser::ConstantExpr &, bool inComponentDecl);
   void CheckExplicitInterface(const parser::Name &);
   void CheckBindings(const parser::TypeBoundProcedureStmt::WithoutInterface &);
 
   const parser::Name *ResolveDesignator(const parser::Designator &);
 
 protected:
   bool BeginDecl();
   void EndDecl();
   Symbol &DeclareObjectEntity(const parser::Name &, Attrs);
   // Make sure that there's an entity in an enclosing scope called Name
   Symbol &FindOrDeclareEnclosingEntity(const parser::Name &);
   // Declare a LOCAL/LOCAL_INIT entity. If there isn't a type specified
   // it comes from the entity in the containing scope, or implicit rules.
   // Return pointer to the new symbol, or nullptr on error.
   Symbol *DeclareLocalEntity(const parser::Name &);
   // Declare a statement entity (e.g., an implied DO loop index).
   // If there isn't a type specified, implicit rules apply.
   // Return pointer to the new symbol, or nullptr on error.
   Symbol *DeclareStatementEntity(
       const parser::Name &, const std::optional<parser::IntegerTypeSpec> &);
   bool CheckUseError(const parser::Name &);
   void CheckAccessibility(const SourceName &, bool, Symbol &);
   void CheckCommonBlocks();
   void CheckSaveStmts();
   void CheckEquivalenceSets();
   bool CheckNotInBlock(const char *);
   bool NameIsKnownOrIntrinsic(const parser::Name &);
 
   // Each of these returns a pointer to a resolved Name (i.e. with symbol)
   // or nullptr in case of error.
   const parser::Name *ResolveStructureComponent(
       const parser::StructureComponent &);
   const parser::Name *ResolveDataRef(const parser::DataRef &);
   const parser::Name *ResolveName(const parser::Name &);
   bool PassesSharedLocalityChecks(const parser::Name &name, Symbol &symbol);
   Symbol *NoteInterfaceName(const parser::Name &);
 
 private:
   // The attribute corresponding to the statement containing an ObjectDecl
   std::optional<Attr> objectDeclAttr_;
   // Info about current character type while walking DeclTypeSpec.
   // Also captures any "*length" specifier on an individual declaration.
   struct {
     std::optional<ParamValue> length;
     std::optional<KindExpr> kind;
   } charInfo_;
   // Info about current derived type while walking DerivedTypeDef
   struct {
     const parser::Name *extends{nullptr}; // EXTENDS(name)
     bool privateComps{false}; // components are private by default
     bool privateBindings{false}; // bindings are private by default
     bool sawContains{false}; // currently processing bindings
     bool sequence{false}; // is a sequence type
     const Symbol *type{nullptr}; // derived type being defined
   } derivedTypeInfo_;
   // Collect equivalence sets and process at end of specification part
   std::vector<const std::list<parser::EquivalenceObject> *> equivalenceSets_;
   // Info about common blocks in the current scope
   struct {
     Symbol *curr{nullptr}; // common block currently being processed
     std::set<SourceName> names; // names in any common block of scope
   } commonBlockInfo_;
   // Info about about SAVE statements and attributes in current scope
   struct {
     std::optional<SourceName> saveAll; // "SAVE" without entity list
     std::set<SourceName> entities; // names of entities with save attr
     std::set<SourceName> commons; // names of common blocks with save attr
   } saveInfo_;
   // In a ProcedureDeclarationStmt or ProcComponentDefStmt, this is
   // the interface name, if any.
   const parser::Name *interfaceName_{nullptr};
   // Map type-bound generic to binding names of its specific bindings
   std::multimap<Symbol *, const parser::Name *> genericBindings_;
   // Info about current ENUM
   struct EnumeratorState {
     // Enum value must hold inside a C_INT (7.6.2).
     std::optional<int> value{0};
   } enumerationState_;
 
   bool HandleAttributeStmt(Attr, const std::list<parser::Name> &);
   Symbol &HandleAttributeStmt(Attr, const parser::Name &);
   Symbol &DeclareUnknownEntity(const parser::Name &, Attrs);
   Symbol &DeclareProcEntity(const parser::Name &, Attrs, const ProcInterface &);
   void SetType(const parser::Name &, const DeclTypeSpec &);
   std::optional<DerivedTypeSpec> ResolveDerivedType(const parser::Name &);
   std::optional<DerivedTypeSpec> ResolveExtendsType(
       const parser::Name &, const parser::Name *);
   Symbol *MakeTypeSymbol(const SourceName &, Details &&);
   Symbol *MakeTypeSymbol(const parser::Name &, Details &&);
   bool OkToAddComponent(const parser::Name &, const Symbol * = nullptr);
   ParamValue GetParamValue(
       const parser::TypeParamValue &, common::TypeParamAttr attr);
   Symbol &MakeCommonBlockSymbol(const parser::Name &);
   void CheckCommonBlockDerivedType(const SourceName &, const Symbol &);
   std::optional<MessageFixedText> CheckSaveAttr(const Symbol &);
   Attrs HandleSaveName(const SourceName &, Attrs);
   void AddSaveName(std::set<SourceName> &, const SourceName &);
   void SetSaveAttr(Symbol &);
   bool HandleUnrestrictedSpecificIntrinsicFunction(const parser::Name &);
   bool IsUplevelReference(const Symbol &);
   const parser::Name *FindComponent(const parser::Name *, const parser::Name &);
   bool CheckInitialDataTarget(const Symbol &, const SomeExpr &, SourceName);
   void CheckInitialProcTarget(const Symbol &, const parser::Name &, SourceName);
   void Initialization(const parser::Name &, const parser::Initialization &,
       bool inComponentDecl);
   bool PassesLocalityChecks(const parser::Name &name, Symbol &symbol);
 
   // Declare an object or procedure entity.
   // T is one of: EntityDetails, ObjectEntityDetails, ProcEntityDetails
   template <typename T>
   Symbol &DeclareEntity(const parser::Name &name, Attrs attrs) {
     Symbol &symbol{MakeSymbol(name, attrs)};
     if (symbol.has<T>()) {
       // OK
     } else if (symbol.has<UnknownDetails>()) {
       symbol.set_details(T{});
     } else if (auto *details{symbol.detailsIf<EntityDetails>()}) {
       symbol.set_details(T{std::move(*details)});
     } else if (std::is_same_v<EntityDetails, T> &&
         (symbol.has<ObjectEntityDetails>() ||
             symbol.has<ProcEntityDetails>())) {
       // OK
     } else if (auto *details{symbol.detailsIf<UseDetails>()}) {
       Say(name.source,
           "'%s' is use-associated from module '%s' and cannot be re-declared"_err_en_US,
           name.source, GetUsedModule(*details).name());
     } else if (auto *details{symbol.detailsIf<SubprogramNameDetails>()}) {
       if (details->kind() == SubprogramKind::Module) {
         Say2(name,
             "Declaration of '%s' conflicts with its use as module procedure"_err_en_US,
             symbol, "Module procedure definition"_en_US);
       } else if (details->kind() == SubprogramKind::Internal) {
         Say2(name,
             "Declaration of '%s' conflicts with its use as internal procedure"_err_en_US,
             symbol, "Internal procedure definition"_en_US);
       } else {
         DIE("unexpected kind");
       }
     } else if (std::is_same_v<ObjectEntityDetails, T> &&
         symbol.has<ProcEntityDetails>()) {
       SayWithDecl(
           name, symbol, "'%s' is already declared as a procedure"_err_en_US);
     } else if (std::is_same_v<ProcEntityDetails, T> &&
         symbol.has<ObjectEntityDetails>()) {
       SayWithDecl(
           name, symbol, "'%s' is already declared as an object"_err_en_US);
     } else {
       SayAlreadyDeclared(name, symbol);
     }
     return symbol;
   }
 };
 
 // Resolve construct entities and statement entities.
 // Check that construct names don't conflict with other names.
 class ConstructVisitor : public virtual DeclarationVisitor {
 public:
   bool Pre(const parser::ConcurrentHeader &);
   bool Pre(const parser::LocalitySpec::Local &);
   bool Pre(const parser::LocalitySpec::LocalInit &);
   bool Pre(const parser::LocalitySpec::Shared &);
   bool Pre(const parser::AcSpec &);
   bool Pre(const parser::AcImpliedDo &);
   bool Pre(const parser::DataImpliedDo &);
   bool Pre(const parser::DataIDoObject &);
   bool Pre(const parser::DataStmtObject &);
   bool Pre(const parser::DataStmtValue &);
   bool Pre(const parser::DoConstruct &);
   void Post(const parser::DoConstruct &);
   bool Pre(const parser::ForallConstruct &);
   void Post(const parser::ForallConstruct &);
   bool Pre(const parser::ForallStmt &);
   void Post(const parser::ForallStmt &);
   bool Pre(const parser::BlockStmt &);
   bool Pre(const parser::EndBlockStmt &);
   void Post(const parser::Selector &);
   bool Pre(const parser::AssociateStmt &);
   void Post(const parser::EndAssociateStmt &);
   void Post(const parser::Association &);
   void Post(const parser::SelectTypeStmt &);
   void Post(const parser::SelectRankStmt &);
   bool Pre(const parser::SelectTypeConstruct &);
   void Post(const parser::SelectTypeConstruct &);
   bool Pre(const parser::SelectTypeConstruct::TypeCase &);
   void Post(const parser::SelectTypeConstruct::TypeCase &);
   // Creates Block scopes with neither symbol name nor symbol details.
   bool Pre(const parser::SelectRankConstruct::RankCase &);
   void Post(const parser::SelectRankConstruct::RankCase &);
   void Post(const parser::TypeGuardStmt::Guard &);
   void Post(const parser::SelectRankCaseStmt::Rank &);
   bool Pre(const parser::ChangeTeamStmt &);
   void Post(const parser::EndChangeTeamStmt &);
   void Post(const parser::CoarrayAssociation &);
 
   // Definitions of construct names
   bool Pre(const parser::WhereConstructStmt &x) { return CheckDef(x.t); }
   bool Pre(const parser::ForallConstructStmt &x) { return CheckDef(x.t); }
   bool Pre(const parser::CriticalStmt &x) { return CheckDef(x.t); }
   bool Pre(const parser::LabelDoStmt &) {
     return false; // error recovery
   }
   bool Pre(const parser::NonLabelDoStmt &x) { return CheckDef(x.t); }
   bool Pre(const parser::IfThenStmt &x) { return CheckDef(x.t); }
   bool Pre(const parser::SelectCaseStmt &x) { return CheckDef(x.t); }
   bool Pre(const parser::SelectRankConstruct &);
   void Post(const parser::SelectRankConstruct &);
   bool Pre(const parser::SelectRankStmt &x) {
     return CheckDef(std::get<0>(x.t));
   }
   bool Pre(const parser::SelectTypeStmt &x) {
     return CheckDef(std::get<0>(x.t));
   }
 
   // References to construct names
   void Post(const parser::MaskedElsewhereStmt &x) { CheckRef(x.t); }
   void Post(const parser::ElsewhereStmt &x) { CheckRef(x.v); }
   void Post(const parser::EndWhereStmt &x) { CheckRef(x.v); }
   void Post(const parser::EndForallStmt &x) { CheckRef(x.v); }
   void Post(const parser::EndCriticalStmt &x) { CheckRef(x.v); }
   void Post(const parser::EndDoStmt &x) { CheckRef(x.v); }
   void Post(const parser::ElseIfStmt &x) { CheckRef(x.t); }
   void Post(const parser::ElseStmt &x) { CheckRef(x.v); }
   void Post(const parser::EndIfStmt &x) { CheckRef(x.v); }
   void Post(const parser::CaseStmt &x) { CheckRef(x.t); }
   void Post(const parser::EndSelectStmt &x) { CheckRef(x.v); }
   void Post(const parser::SelectRankCaseStmt &x) { CheckRef(x.t); }
   void Post(const parser::TypeGuardStmt &x) { CheckRef(x.t); }
   void Post(const parser::CycleStmt &x) { CheckRef(x.v); }
   void Post(const parser::ExitStmt &x) { CheckRef(x.v); }
 
 private:
   // R1105 selector -> expr | variable
   // expr is set in either case unless there were errors
   struct Selector {
     Selector() {}
     Selector(const SourceName &source, MaybeExpr &&expr)
         : source{source}, expr{std::move(expr)} {}
     operator bool() const { return expr.has_value(); }
     parser::CharBlock source;
     MaybeExpr expr;
   };
   // association -> [associate-name =>] selector
   struct Association {
     const parser::Name *name{nullptr};
     Selector selector;
   };
   std::vector<Association> associationStack_;
 
   template <typename T> bool CheckDef(const T &t) {
     return CheckDef(std::get<std::optional<parser::Name>>(t));
   }
   template <typename T> void CheckRef(const T &t) {
     CheckRef(std::get<std::optional<parser::Name>>(t));
   }
   bool CheckDef(const std::optional<parser::Name> &);
   void CheckRef(const std::optional<parser::Name> &);
   const DeclTypeSpec &ToDeclTypeSpec(evaluate::DynamicType &&);
   const DeclTypeSpec &ToDeclTypeSpec(
       evaluate::DynamicType &&, MaybeSubscriptIntExpr &&length);
   Symbol *MakeAssocEntity();
   void SetTypeFromAssociation(Symbol &);
   void SetAttrsFromAssociation(Symbol &);
   Selector ResolveSelector(const parser::Selector &);
   void ResolveIndexName(const parser::ConcurrentControl &control);
   Association &GetCurrentAssociation();
   void PushAssociation();
   void PopAssociation();
 };
 
 // Create scopes for OpenACC constructs
 class AccVisitor : public virtual DeclarationVisitor {
 public:
   void AddAccSourceRange(const parser::CharBlock &);
 
   static bool NeedsScope(const parser::OpenACCBlockConstruct &);
 
   bool Pre(const parser::OpenACCBlockConstruct &);
   void Post(const parser::OpenACCBlockConstruct &);
   bool Pre(const parser::AccBeginBlockDirective &x) {
     AddAccSourceRange(x.source);
     return true;
   }
   void Post(const parser::AccBeginBlockDirective &) {
     messageHandler().set_currStmtSource(std::nullopt);
   }
   bool Pre(const parser::AccEndBlockDirective &x) {
     AddAccSourceRange(x.source);
     return true;
   }
   void Post(const parser::AccEndBlockDirective &) {
     messageHandler().set_currStmtSource(std::nullopt);
   }
   bool Pre(const parser::AccBeginLoopDirective &x) {
     AddAccSourceRange(x.source);
     return true;
   }
   void Post(const parser::AccBeginLoopDirective &x) {
     messageHandler().set_currStmtSource(std::nullopt);
   }
 };
 
 bool AccVisitor::NeedsScope(const parser::OpenACCBlockConstruct &x) {
   const auto &beginBlockDir{std::get<parser::AccBeginBlockDirective>(x.t)};
   const auto &beginDir{std::get<parser::AccBlockDirective>(beginBlockDir.t)};
   switch (beginDir.v) {
   case llvm::acc::Directive::ACCD_data:
   case llvm::acc::Directive::ACCD_host_data:
   case llvm::acc::Directive::ACCD_kernels:
   case llvm::acc::Directive::ACCD_parallel:
   case llvm::acc::Directive::ACCD_serial:
     return true;
   default:
     return false;
   }
 }
 
 void AccVisitor::AddAccSourceRange(const parser::CharBlock &source) {
   messageHandler().set_currStmtSource(source);
   currScope().AddSourceRange(source);
 }
 
 bool AccVisitor::Pre(const parser::OpenACCBlockConstruct &x) {
   if (NeedsScope(x)) {
     PushScope(Scope::Kind::Block, nullptr);
   }
   return true;
 }
 
 void AccVisitor::Post(const parser::OpenACCBlockConstruct &x) {
   if (NeedsScope(x)) {
     PopScope();
   }
 }
 
 // Create scopes for OpenMP constructs
 class OmpVisitor : public virtual DeclarationVisitor {
 public:
   void AddOmpSourceRange(const parser::CharBlock &);
 
   static bool NeedsScope(const parser::OpenMPBlockConstruct &);
 
   bool Pre(const parser::OpenMPBlockConstruct &);
   void Post(const parser::OpenMPBlockConstruct &);
   bool Pre(const parser::OmpBeginBlockDirective &x) {
     AddOmpSourceRange(x.source);
     return true;
   }
   void Post(const parser::OmpBeginBlockDirective &) {
     messageHandler().set_currStmtSource(std::nullopt);
   }
   bool Pre(const parser::OmpEndBlockDirective &x) {
     AddOmpSourceRange(x.source);
     return true;
   }
   void Post(const parser::OmpEndBlockDirective &) {
     messageHandler().set_currStmtSource(std::nullopt);
   }
 
   bool Pre(const parser::OpenMPLoopConstruct &) {
     PushScope(Scope::Kind::Block, nullptr);
     return true;
   }
   void Post(const parser::OpenMPLoopConstruct &) { PopScope(); }
   bool Pre(const parser::OmpBeginLoopDirective &x) {
     AddOmpSourceRange(x.source);
     return true;
   }
   void Post(const parser::OmpBeginLoopDirective &) {
     messageHandler().set_currStmtSource(std::nullopt);
   }
   bool Pre(const parser::OmpEndLoopDirective &x) {
     AddOmpSourceRange(x.source);
     return true;
   }
   void Post(const parser::OmpEndLoopDirective &) {
     messageHandler().set_currStmtSource(std::nullopt);
   }
 
   bool Pre(const parser::OpenMPSectionsConstruct &) {
     PushScope(Scope::Kind::Block, nullptr);
     return true;
   }
   void Post(const parser::OpenMPSectionsConstruct &) { PopScope(); }
   bool Pre(const parser::OmpBeginSectionsDirective &x) {
     AddOmpSourceRange(x.source);
     return true;
   }
   void Post(const parser::OmpBeginSectionsDirective &) {
     messageHandler().set_currStmtSource(std::nullopt);
   }
   bool Pre(const parser::OmpEndSectionsDirective &x) {
     AddOmpSourceRange(x.source);
     return true;
   }
   void Post(const parser::OmpEndSectionsDirective &) {
     messageHandler().set_currStmtSource(std::nullopt);
   }
 };
 
 bool OmpVisitor::NeedsScope(const parser::OpenMPBlockConstruct &x) {
   const auto &beginBlockDir{std::get<parser::OmpBeginBlockDirective>(x.t)};
   const auto &beginDir{std::get<parser::OmpBlockDirective>(beginBlockDir.t)};
   switch (beginDir.v) {
   case llvm::omp::Directive::OMPD_target_data:
   case llvm::omp::Directive::OMPD_master:
   case llvm::omp::Directive::OMPD_ordered:
     return false;
   default:
     return true;
   }
 }
 
 void OmpVisitor::AddOmpSourceRange(const parser::CharBlock &source) {
   messageHandler().set_currStmtSource(source);
   currScope().AddSourceRange(source);
 }
 
 bool OmpVisitor::Pre(const parser::OpenMPBlockConstruct &x) {
   if (NeedsScope(x)) {
     PushScope(Scope::Kind::Block, nullptr);
   }
   return true;
 }
 
 void OmpVisitor::Post(const parser::OpenMPBlockConstruct &x) {
   if (NeedsScope(x)) {
     PopScope();
   }
 }
 
 // Walk the parse tree and resolve names to symbols.
 class ResolveNamesVisitor : public virtual ScopeHandler,
                             public ModuleVisitor,
                             public SubprogramVisitor,
                             public ConstructVisitor,
                             public OmpVisitor,
                             public AccVisitor {
 public:
   using AccVisitor::Post;
   using AccVisitor::Pre;
   using ArraySpecVisitor::Post;
   using ConstructVisitor::Post;
   using ConstructVisitor::Pre;
   using DeclarationVisitor::Post;
   using DeclarationVisitor::Pre;
   using ImplicitRulesVisitor::Post;
   using ImplicitRulesVisitor::Pre;
   using InterfaceVisitor::Post;
   using InterfaceVisitor::Pre;
   using ModuleVisitor::Post;
   using ModuleVisitor::Pre;
   using OmpVisitor::Post;
   using OmpVisitor::Pre;
   using ScopeHandler::Post;
   using ScopeHandler::Pre;
   using SubprogramVisitor::Post;
   using SubprogramVisitor::Pre;
 
   ResolveNamesVisitor(SemanticsContext &context, ImplicitRulesMap &rules)
       : BaseVisitor{context, *this, rules} {
     PushScope(context.globalScope());
   }
 
   // Default action for a parse tree node is to visit children.
   template <typename T> bool Pre(const T &) { return true; }
   template <typename T> void Post(const T &) {}
 
   bool Pre(const parser::SpecificationPart &);
   void Post(const parser::Program &);
   bool Pre(const parser::ImplicitStmt &);
   void Post(const parser::PointerObject &);
   void Post(const parser::AllocateObject &);
   bool Pre(const parser::PointerAssignmentStmt &);
   void Post(const parser::Designator &);
   template <typename A, typename B>
   void Post(const parser::LoopBounds<A, B> &x) {
     ResolveName(*parser::Unwrap<parser::Name>(x.name));
   }
   void Post(const parser::ProcComponentRef &);
   bool Pre(const parser::ActualArg &);
   bool Pre(const parser::FunctionReference &);
   bool Pre(const parser::CallStmt &);
   bool Pre(const parser::ImportStmt &);
   void Post(const parser::TypeGuardStmt &);
   bool Pre(const parser::StmtFunctionStmt &);
   bool Pre(const parser::DefinedOpName &);
   bool Pre(const parser::ProgramUnit &);
   void Post(const parser::AssignStmt &);
   void Post(const parser::AssignedGotoStmt &);
 
   // These nodes should never be reached: they are handled in ProgramUnit
   bool Pre(const parser::MainProgram &) {
     llvm_unreachable("This node is handled in ProgramUnit");
   }
   bool Pre(const parser::FunctionSubprogram &) {
     llvm_unreachable("This node is handled in ProgramUnit");
   }
   bool Pre(const parser::SubroutineSubprogram &) {
     llvm_unreachable("This node is handled in ProgramUnit");
   }
   bool Pre(const parser::SeparateModuleSubprogram &) {
     llvm_unreachable("This node is handled in ProgramUnit");
   }
   bool Pre(const parser::Module &) {
     llvm_unreachable("This node is handled in ProgramUnit");
   }
   bool Pre(const parser::Submodule &) {
     llvm_unreachable("This node is handled in ProgramUnit");
   }
   bool Pre(const parser::BlockData &) {
     llvm_unreachable("This node is handled in ProgramUnit");
   }
 
   void NoteExecutablePartCall(Symbol::Flag, const parser::Call &);
 
   friend void ResolveSpecificationParts(SemanticsContext &, const Symbol &);
 
 private:
   // Kind of procedure we are expecting to see in a ProcedureDesignator
   std::optional<Symbol::Flag> expectedProcFlag_;
   std::optional<SourceName> prevImportStmt_;
 
   void PreSpecificationConstruct(const parser::SpecificationConstruct &);
   void CreateGeneric(const parser::GenericSpec &);
   void FinishSpecificationPart(const std::list<parser::DeclarationConstruct> &);
   void AnalyzeStmtFunctionStmt(const parser::StmtFunctionStmt &);
   void CheckImports();
   void CheckImport(const SourceName &, const SourceName &);
   void HandleCall(Symbol::Flag, const parser::Call &);
   void HandleProcedureName(Symbol::Flag, const parser::Name &);
   bool SetProcFlag(const parser::Name &, Symbol &, Symbol::Flag);
   void ResolveSpecificationParts(ProgramTree &);
   void AddSubpNames(ProgramTree &);
   bool BeginScopeForNode(const ProgramTree &);
   void FinishSpecificationParts(const ProgramTree &);
   void FinishDerivedTypeInstantiation(Scope &);
   void ResolveExecutionParts(const ProgramTree &);
 };
 
 // ImplicitRules implementation
 
 bool ImplicitRules::isImplicitNoneType() const {
   if (isImplicitNoneType_) {
     return true;
   } else if (map_.empty() && inheritFromParent_) {
     return parent_->isImplicitNoneType();
   } else {
     return false; // default if not specified
   }
 }
 
 bool ImplicitRules::isImplicitNoneExternal() const {
   if (isImplicitNoneExternal_) {
     return true;
   } else if (inheritFromParent_) {
     return parent_->isImplicitNoneExternal();
   } else {
     return false; // default if not specified
   }
 }
 
 const DeclTypeSpec *ImplicitRules::GetType(char ch) const {
   if (isImplicitNoneType_) {
     return nullptr;
   } else if (auto it{map_.find(ch)}; it != map_.end()) {
     return &*it->second;
   } else if (inheritFromParent_) {
     return parent_->GetType(ch);
   } else if (ch >= 'i' && ch <= 'n') {
     return &context_.MakeNumericType(TypeCategory::Integer);
   } else if (ch >= 'a' && ch <= 'z') {
     return &context_.MakeNumericType(TypeCategory::Real);
   } else {
     return nullptr;
   }
 }
 
 void ImplicitRules::SetTypeMapping(const DeclTypeSpec &type,
     parser::Location fromLetter, parser::Location toLetter) {
   for (char ch = *fromLetter; ch; ch = ImplicitRules::Incr(ch)) {
     auto res{map_.emplace(ch, type)};
     if (!res.second) {
       context_.Say(parser::CharBlock{fromLetter},
           "More than one implicit type specified for '%c'"_err_en_US, ch);
     }
     if (ch == *toLetter) {
       break;
     }
   }
 }
 
 // Return the next char after ch in a way that works for ASCII or EBCDIC.
 // Return '\0' for the char after 'z'.
 char ImplicitRules::Incr(char ch) {
   switch (ch) {
   case 'i':
     return 'j';
   case 'r':
     return 's';
   case 'z':
     return '\0';
   default:
     return ch + 1;
   }
 }
 
 llvm::raw_ostream &operator<<(
     llvm::raw_ostream &o, const ImplicitRules &implicitRules) {
   o << "ImplicitRules:\n";
   for (char ch = 'a'; ch; ch = ImplicitRules::Incr(ch)) {
     ShowImplicitRule(o, implicitRules, ch);
   }
   ShowImplicitRule(o, implicitRules, '_');
   ShowImplicitRule(o, implicitRules, '$');
   ShowImplicitRule(o, implicitRules, '@');
   return o;
 }
 void ShowImplicitRule(
     llvm::raw_ostream &o, const ImplicitRules &implicitRules, char ch) {
   auto it{implicitRules.map_.find(ch)};
   if (it != implicitRules.map_.end()) {
     o << "  " << ch << ": " << *it->second << '\n';
   }
 }
 
 template <typename T> void BaseVisitor::Walk(const T &x) {
   parser::Walk(x, *this_);
 }
 
 void BaseVisitor::MakePlaceholder(
     const parser::Name &name, MiscDetails::Kind kind) {
   if (!name.symbol) {
     name.symbol = &context_->globalScope().MakeSymbol(
         name.source, Attrs{}, MiscDetails{kind});
   }
 }
 
 // AttrsVisitor implementation
 
 bool AttrsVisitor::BeginAttrs() {
   CHECK(!attrs_);
   attrs_ = std::make_optional<Attrs>();
   return true;
 }
 Attrs AttrsVisitor::GetAttrs() {
   CHECK(attrs_);
   return *attrs_;
 }
 Attrs AttrsVisitor::EndAttrs() {
   Attrs result{GetAttrs()};
   attrs_.reset();
   passName_ = std::nullopt;
   bindName_.reset();
   return result;
 }
 
 bool AttrsVisitor::SetPassNameOn(Symbol &symbol) {
   if (!passName_) {
     return false;
   }
   std::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;
 }
 
 bool AttrsVisitor::SetBindNameOn(Symbol &symbol) {
   if (!bindName_) {
     return false;
   }
   std::visit(
       common::visitors{
           [&](EntityDetails &x) { x.set_bindName(std::move(bindName_)); },
           [&](ObjectEntityDetails &x) { x.set_bindName(std::move(bindName_)); },
           [&](ProcEntityDetails &x) { x.set_bindName(std::move(bindName_)); },
           [&](SubprogramDetails &x) { x.set_bindName(std::move(bindName_)); },
           [&](CommonBlockDetails &x) { x.set_bindName(std::move(bindName_)); },
           [](auto &) { common::die("unexpected bind name"); },
       },
       symbol.details());
   return true;
 }
 
 void AttrsVisitor::Post(const parser::LanguageBindingSpec &x) {
   CHECK(attrs_);
   if (CheckAndSet(Attr::BIND_C)) {
     if (x.v) {
       bindName_ = EvaluateExpr(*x.v);
     }
   }
 }
 bool AttrsVisitor::Pre(const parser::IntentSpec &x) {
   CHECK(attrs_);
   CheckAndSet(IntentSpecToAttr(x));
   return false;
 }
 bool AttrsVisitor::Pre(const parser::Pass &x) {
   if (CheckAndSet(Attr::PASS)) {
     if (x.v) {
       passName_ = x.v->source;
       MakePlaceholder(*x.v, MiscDetails::Kind::PassName);
     }
   }
   return false;
 }
 
 // C730, C743, C755, C778, C1543 say no attribute or prefix repetitions
 bool AttrsVisitor::IsDuplicateAttr(Attr attrName) {
   if (attrs_->test(attrName)) {
     Say(currStmtSource().value(),
         "Attribute '%s' cannot be used more than once"_en_US,
         AttrToString(attrName));
     return true;
   }
   return false;
 }
 
 // See if attrName violates a constraint cause by a conflict.  attr1 and attr2
 // name attributes that cannot be used on the same declaration
 bool AttrsVisitor::HaveAttrConflict(Attr attrName, Attr attr1, Attr attr2) {
   if ((attrName == attr1 && attrs_->test(attr2)) ||
       (attrName == attr2 && attrs_->test(attr1))) {
     Say(currStmtSource().value(),
         "Attributes '%s' and '%s' conflict with each other"_err_en_US,
         AttrToString(attr1), AttrToString(attr2));
     return true;
   }
   return false;
 }
 // C759, C1543
 bool AttrsVisitor::IsConflictingAttr(Attr attrName) {
   return HaveAttrConflict(attrName, Attr::INTENT_IN, Attr::INTENT_INOUT) ||
       HaveAttrConflict(attrName, Attr::INTENT_IN, Attr::INTENT_OUT) ||
       HaveAttrConflict(attrName, Attr::INTENT_INOUT, Attr::INTENT_OUT) ||
       HaveAttrConflict(attrName, Attr::PASS, Attr::NOPASS) || // C781
       HaveAttrConflict(attrName, Attr::PURE, Attr::IMPURE) ||
       HaveAttrConflict(attrName, Attr::PUBLIC, Attr::PRIVATE) ||
       HaveAttrConflict(attrName, Attr::RECURSIVE, Attr::NON_RECURSIVE);
 }
 bool AttrsVisitor::CheckAndSet(Attr attrName) {
   CHECK(attrs_);
   if (IsConflictingAttr(attrName) || IsDuplicateAttr(attrName)) {
     return false;
   }
   attrs_->set(attrName);
   return true;
 }
 
 // DeclTypeSpecVisitor implementation
 
 const DeclTypeSpec *DeclTypeSpecVisitor::GetDeclTypeSpec() {
   return state_.declTypeSpec;
 }
 
 void DeclTypeSpecVisitor::BeginDeclTypeSpec() {
   CHECK(!state_.expectDeclTypeSpec);
   CHECK(!state_.declTypeSpec);
   state_.expectDeclTypeSpec = true;
 }
 void DeclTypeSpecVisitor::EndDeclTypeSpec() {
   CHECK(state_.expectDeclTypeSpec);
   state_ = {};
 }
 
 void DeclTypeSpecVisitor::SetDeclTypeSpecCategory(
     DeclTypeSpec::Category category) {
   CHECK(state_.expectDeclTypeSpec);
   state_.derived.category = category;
 }
 
 bool DeclTypeSpecVisitor::Pre(const parser::TypeGuardStmt &) {
   BeginDeclTypeSpec();
   return true;
 }
 void DeclTypeSpecVisitor::Post(const parser::TypeGuardStmt &) {
   EndDeclTypeSpec();
 }
 
 void DeclTypeSpecVisitor::Post(const parser::TypeSpec &typeSpec) {
   // Record the resolved DeclTypeSpec in the parse tree for use by
   // expression semantics if the DeclTypeSpec is a valid TypeSpec.
   // The grammar ensures that it's an intrinsic or derived type spec,
   // not TYPE(*) or CLASS(*) or CLASS(T).
   if (const DeclTypeSpec * spec{state_.declTypeSpec}) {
     switch (spec->category()) {
     case DeclTypeSpec::Numeric:
     case DeclTypeSpec::Logical:
     case DeclTypeSpec::Character:
       typeSpec.declTypeSpec = spec;
       break;
     case DeclTypeSpec::TypeDerived:
       if (const DerivedTypeSpec * derived{spec->AsDerived()}) {
         CheckForAbstractType(derived->typeSymbol()); // C703
         typeSpec.declTypeSpec = spec;
       }
       break;
     default:
       CRASH_NO_CASE;
     }
   }
 }
 
 void DeclTypeSpecVisitor::Post(
     const parser::IntrinsicTypeSpec::DoublePrecision &) {
   MakeNumericType(TypeCategory::Real, context().doublePrecisionKind());
 }
 void DeclTypeSpecVisitor::Post(
     const parser::IntrinsicTypeSpec::DoubleComplex &) {
   MakeNumericType(TypeCategory::Complex, context().doublePrecisionKind());
 }
 void DeclTypeSpecVisitor::MakeNumericType(TypeCategory category, int kind) {
   SetDeclTypeSpec(context().MakeNumericType(category, kind));
 }
 
 void DeclTypeSpecVisitor::CheckForAbstractType(const Symbol &typeSymbol) {
   if (typeSymbol.attrs().test(Attr::ABSTRACT)) {
     Say("ABSTRACT derived type may not be used here"_err_en_US);
   }
 }
 
 void DeclTypeSpecVisitor::Post(const parser::DeclarationTypeSpec::ClassStar &) {
   SetDeclTypeSpec(context().globalScope().MakeClassStarType());
 }
 void DeclTypeSpecVisitor::Post(const parser::DeclarationTypeSpec::TypeStar &) {
   SetDeclTypeSpec(context().globalScope().MakeTypeStarType());
 }
 
 // Check that we're expecting to see a DeclTypeSpec (and haven't seen one yet)
 // and save it in state_.declTypeSpec.
 void DeclTypeSpecVisitor::SetDeclTypeSpec(const DeclTypeSpec &declTypeSpec) {
   CHECK(state_.expectDeclTypeSpec);
   CHECK(!state_.declTypeSpec);
   state_.declTypeSpec = &declTypeSpec;
 }
 
 KindExpr DeclTypeSpecVisitor::GetKindParamExpr(
     TypeCategory category, const std::optional<parser::KindSelector> &kind) {
   return AnalyzeKindSelector(context(), category, kind);
 }
 
 // MessageHandler implementation
 
 Message &MessageHandler::Say(MessageFixedText &&msg) {
   return context_->Say(currStmtSource().value(), std::move(msg));
 }
 Message &MessageHandler::Say(MessageFormattedText &&msg) {
   return context_->Say(currStmtSource().value(), std::move(msg));
 }
 Message &MessageHandler::Say(const SourceName &name, MessageFixedText &&msg) {
   return Say(name, std::move(msg), name);
 }
 
 // ImplicitRulesVisitor implementation
 
 void ImplicitRulesVisitor::Post(const parser::ParameterStmt &) {
   prevParameterStmt_ = currStmtSource();
 }
 
 bool ImplicitRulesVisitor::Pre(const parser::ImplicitStmt &x) {
   bool result{
       std::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};
   if (auto hiLocOpt{std::get<std::optional<parser::Location>>(x.t)}) {
     hiLoc = *hiLocOpt;
     if (*hiLoc < *loLoc) {
       Say(hiLoc, "'%s' does not follow '%s' alphabetically"_err_en_US,
           std::string(hiLoc, 1), std::string(loLoc, 1));
       return false;
     }
   }
   implicitRules().SetTypeMapping(*GetDeclTypeSpec(), loLoc, hiLoc);
   return false;
 }
 
 bool ImplicitRulesVisitor::Pre(const parser::ImplicitSpec &) {
   BeginDeclTypeSpec();
   set_allowForwardReferenceToDerivedType(true);
   return true;
 }
 
 void ImplicitRulesVisitor::Post(const parser::ImplicitSpec &) {
   EndDeclTypeSpec();
 }
 
 void ImplicitRulesVisitor::SetScope(const Scope &scope) {
   implicitRules_ = &DEREF(implicitRulesMap_).at(&scope);
   prevImplicit_ = std::nullopt;
   prevImplicitNone_ = std::nullopt;
   prevImplicitNoneType_ = std::nullopt;
   prevParameterStmt_ = std::nullopt;
 }
 void ImplicitRulesVisitor::BeginScope(const Scope &scope) {
   // find or create implicit rules for this scope
   DEREF(implicitRulesMap_).try_emplace(&scope, context(), implicitRules_);
   SetScope(scope);
 }
 
 // TODO: for all of these errors, reference previous statement too
 bool ImplicitRulesVisitor::HandleImplicitNone(
     const std::list<ImplicitNoneNameSpec> &nameSpecs) {
   if (prevImplicitNone_) {
     Say("More than one IMPLICIT NONE statement"_err_en_US);
     Say(*prevImplicitNone_, "Previous IMPLICIT NONE statement"_en_US);
     return false;
   }
   if (prevParameterStmt_) {
     Say("IMPLICIT NONE statement after PARAMETER statement"_err_en_US);
     return false;
   }
   prevImplicitNone_ = currStmtSource();
   bool implicitNoneTypeNever{
       context().IsEnabled(common::LanguageFeature::ImplicitNoneTypeNever)};
   if (nameSpecs.empty()) {
     if (!implicitNoneTypeNever) {
       prevImplicitNoneType_ = currStmtSource();
       implicitRules().set_isImplicitNoneType(true);
       if (prevImplicit_) {
         Say("IMPLICIT NONE statement after IMPLICIT statement"_err_en_US);
         return false;
       }
     }
   } else {
     int sawType{0};
     int sawExternal{0};
     for (const auto noneSpec : nameSpecs) {
       switch (noneSpec) {
       case ImplicitNoneNameSpec::External:
         implicitRules().set_isImplicitNoneExternal(true);
         ++sawExternal;
         break;
       case ImplicitNoneNameSpec::Type:
         if (!implicitNoneTypeNever) {
           prevImplicitNoneType_ = currStmtSource();
           implicitRules().set_isImplicitNoneType(true);
           if (prevImplicit_) {
             Say("IMPLICIT NONE(TYPE) after IMPLICIT statement"_err_en_US);
             return false;
           }
           ++sawType;
         }
         break;
       }
     }
     if (sawType > 1) {
       Say("TYPE specified more than once in IMPLICIT NONE statement"_err_en_US);
       return false;
     }
     if (sawExternal > 1) {
       Say("EXTERNAL specified more than once in IMPLICIT NONE statement"_err_en_US);
       return false;
     }
   }
   return true;
 }
 
 // ArraySpecVisitor implementation
 
 void ArraySpecVisitor::Post(const parser::ArraySpec &x) {
   CHECK(arraySpec_.empty());
   arraySpec_ = AnalyzeArraySpec(context(), x);
 }
 void ArraySpecVisitor::Post(const parser::ComponentArraySpec &x) {
   CHECK(arraySpec_.empty());
   arraySpec_ = AnalyzeArraySpec(context(), x);
 }
 void ArraySpecVisitor::Post(const parser::CoarraySpec &x) {
   CHECK(coarraySpec_.empty());
   coarraySpec_ = AnalyzeCoarraySpec(context(), x);
 }
 
 const ArraySpec &ArraySpecVisitor::arraySpec() {
   return !arraySpec_.empty() ? arraySpec_ : attrArraySpec_;
 }
 const ArraySpec &ArraySpecVisitor::coarraySpec() {
   return !coarraySpec_.empty() ? coarraySpec_ : attrCoarraySpec_;
 }
 void ArraySpecVisitor::BeginArraySpec() {
   CHECK(arraySpec_.empty());
   CHECK(coarraySpec_.empty());
   CHECK(attrArraySpec_.empty());
   CHECK(attrCoarraySpec_.empty());
 }
 void ArraySpecVisitor::EndArraySpec() {
   CHECK(arraySpec_.empty());
   CHECK(coarraySpec_.empty());
   attrArraySpec_.clear();
   attrCoarraySpec_.clear();
 }
 void ArraySpecVisitor::PostAttrSpec() {
   // Save dimension/codimension from attrs so we can process array/coarray-spec
   // on the entity-decl
   if (!arraySpec_.empty()) {
     if (attrArraySpec_.empty()) {
       attrArraySpec_ = arraySpec_;
       arraySpec_.clear();
     } else {
       Say(currStmtSource().value(),
           "Attribute 'DIMENSION' cannot be used more than once"_err_en_US);
     }
   }
   if (!coarraySpec_.empty()) {
     if (attrCoarraySpec_.empty()) {
       attrCoarraySpec_ = coarraySpec_;
       coarraySpec_.clear();
     } else {
       Say(currStmtSource().value(),
           "Attribute 'CODIMENSION' cannot be used more than once"_err_en_US);
     }
   }
 }
 
 // ScopeHandler implementation
 
 void ScopeHandler::SayAlreadyDeclared(const parser::Name &name, Symbol &prev) {
   SayAlreadyDeclared(name.source, prev);
 }
 void ScopeHandler::SayAlreadyDeclared(const SourceName &name, Symbol &prev) {
   if (context().HasError(prev)) {
     // don't report another error about prev
   } else if (const auto *details{prev.detailsIf<UseDetails>()}) {
     Say(name, "'%s' is already declared in this scoping unit"_err_en_US)
         .Attach(details->location(),
             "It is use-associated with '%s' in module '%s'"_err_en_US,
             details->symbol().name(), GetUsedModule(*details).name());
   } else {
     SayAlreadyDeclared(name, prev.name());
   }
   context().SetError(prev);
 }
 void ScopeHandler::SayAlreadyDeclared(
     const SourceName &name1, const SourceName &name2) {
   if (name1.begin() < name2.begin()) {
     SayAlreadyDeclared(name2, name1);
   } else {
     Say(name1, "'%s' is already declared in this scoping unit"_err_en_US)
         .Attach(name2, "Previous declaration of '%s'"_en_US, name2);
   }
 }
 
 void ScopeHandler::SayWithReason(const parser::Name &name, Symbol &symbol,
     MessageFixedText &&msg1, MessageFixedText &&msg2) {
   Say2(name, std::move(msg1), symbol, std::move(msg2));
   context().SetError(symbol, msg1.isFatal());
 }
 
 void ScopeHandler::SayWithDecl(
     const parser::Name &name, Symbol &symbol, MessageFixedText &&msg) {
   SayWithReason(name, symbol, std::move(msg),
       symbol.test(Symbol::Flag::Implicit) ? "Implicit declaration of '%s'"_en_US
                                           : "Declaration of '%s'"_en_US);
 }
 
 void ScopeHandler::SayLocalMustBeVariable(
     const parser::Name &name, Symbol &symbol) {
   SayWithDecl(name, symbol,
       "The name '%s' must be a variable to appear"
       " in a locality-spec"_err_en_US);
 }
 
 void ScopeHandler::SayDerivedType(
     const SourceName &name, MessageFixedText &&msg, const Scope &type) {
   const Symbol &typeSymbol{DEREF(type.GetSymbol())};
   Say(name, std::move(msg), name, typeSymbol.name())
       .Attach(typeSymbol.name(), "Declaration of derived type '%s'"_en_US,
           typeSymbol.name());
 }
 void ScopeHandler::Say2(const SourceName &name1, MessageFixedText &&msg1,
     const SourceName &name2, MessageFixedText &&msg2) {
   Say(name1, std::move(msg1)).Attach(name2, std::move(msg2), name2);
 }
 void ScopeHandler::Say2(const SourceName &name, MessageFixedText &&msg1,
     Symbol &symbol, MessageFixedText &&msg2) {
   Say2(name, std::move(msg1), symbol.name(), std::move(msg2));
   context().SetError(symbol, msg1.isFatal());
 }
 void ScopeHandler::Say2(const parser::Name &name, MessageFixedText &&msg1,
     Symbol &symbol, MessageFixedText &&msg2) {
   Say2(name.source, std::move(msg1), symbol.name(), std::move(msg2));
   context().SetError(symbol, msg1.isFatal());
 }
 
 Scope &ScopeHandler::InclusiveScope() {
   for (auto *scope{&currScope()};; scope = &scope->parent()) {
     if (scope->kind() != Scope::Kind::Block && !scope->IsDerivedType() &&
         !scope->IsStmtFunction()) {
       return *scope;
     }
   }
   DIE("inclusive scope not found");
 }
 
 Scope &ScopeHandler::NonDerivedTypeScope() {
   return currScope_->IsDerivedType() ? currScope_->parent() : *currScope_;
 }
 
 void ScopeHandler::PushScope(Scope::Kind kind, Symbol *symbol) {
   PushScope(currScope().MakeScope(kind, symbol));
 }
 void ScopeHandler::PushScope(Scope &scope) {
   currScope_ = &scope;
   auto kind{currScope_->kind()};
   if (kind != Scope::Kind::Block) {
     BeginScope(scope);
   }
   // The name of a module or submodule cannot be "used" in its scope,
   // as we read 19.3.1(2), so we allow the name to be used as a local
   // identifier in the module or submodule too.  Same with programs
   // (14.1(3)) and BLOCK DATA.
   if (!currScope_->IsDerivedType() && kind != Scope::Kind::Module &&
       kind != Scope::Kind::MainProgram && kind != Scope::Kind::BlockData) {
     if (auto *symbol{scope.symbol()}) {
       // Create a dummy symbol so we can't create another one with the same
       // name. It might already be there if we previously pushed the scope.
       if (!FindInScope(scope, symbol->name())) {
         auto &newSymbol{MakeSymbol(symbol->name())};
         if (kind == Scope::Kind::Subprogram) {
           // Allow for recursive references.  If this symbol is a function
           // without an explicit RESULT(), this new symbol will be discarded
           // and replaced with an object of the same name.
           newSymbol.set_details(HostAssocDetails{*symbol});
         } else {
           newSymbol.set_details(MiscDetails{MiscDetails::Kind::ScopeName});
         }
       }
     }
   }
 }
 void ScopeHandler::PopScope() {
   // Entities that are not yet classified as objects or procedures are now
   // assumed to be objects.
   // TODO: Statement functions
   for (auto &pair : currScope()) {
     ConvertToObjectEntity(*pair.second);
   }
   SetScope(currScope_->parent());
 }
 void ScopeHandler::SetScope(Scope &scope) {
   currScope_ = &scope;
   ImplicitRulesVisitor::SetScope(InclusiveScope());
 }
 
 Symbol *ScopeHandler::FindSymbol(const parser::Name &name) {
   return FindSymbol(currScope(), name);
 }
 Symbol *ScopeHandler::FindSymbol(const Scope &scope, const parser::Name &name) {
   if (scope.IsDerivedType()) {
     if (Symbol * symbol{scope.FindComponent(name.source)}) {
       if (!symbol->has<ProcBindingDetails>() &&
           !symbol->test(Symbol::Flag::ParentComp)) {
         return Resolve(name, symbol);
       }
     }
     return FindSymbol(scope.parent(), name);
   } else {
     return Resolve(name, scope.FindSymbol(name.source));
   }
 }
 
 Symbol &ScopeHandler::MakeSymbol(
     Scope &scope, const SourceName &name, Attrs attrs) {
   if (Symbol * symbol{FindInScope(scope, name)}) {
     symbol->attrs() |= attrs;
     return *symbol;
   } else {
     const auto pair{scope.try_emplace(name, attrs, UnknownDetails{})};
     CHECK(pair.second); // name was not found, so must be able to add
     return *pair.first->second;
   }
 }
 Symbol &ScopeHandler::MakeSymbol(const SourceName &name, Attrs attrs) {
   return MakeSymbol(currScope(), name, attrs);
 }
 Symbol &ScopeHandler::MakeSymbol(const parser::Name &name, Attrs attrs) {
   return Resolve(name, MakeSymbol(name.source, attrs));
 }
 Symbol &ScopeHandler::CopySymbol(const SourceName &name, const Symbol &symbol) {
   CHECK(!FindInScope(currScope(), name));
   return MakeSymbol(currScope(), name, symbol.attrs());
 }
 
 // Look for name only in scope, not in enclosing scopes.
 Symbol *ScopeHandler::FindInScope(
     const Scope &scope, const parser::Name &name) {
   return Resolve(name, FindInScope(scope, name.source));
 }
 Symbol *ScopeHandler::FindInScope(const Scope &scope, const SourceName &name) {
   if (auto it{scope.find(name)}; it != scope.end()) {
     return &*it->second;
   } else {
     return nullptr;
   }
 }
 
 // Find a component or type parameter by name in a derived type or its parents.
 Symbol *ScopeHandler::FindInTypeOrParents(
     const Scope &scope, const parser::Name &name) {
   return Resolve(name, scope.FindComponent(name.source));
 }
 Symbol *ScopeHandler::FindInTypeOrParents(const parser::Name &name) {
   return FindInTypeOrParents(currScope(), name);
 }
 
 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{
                      [](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) {
   if (NeedsType(symbol)) {
     if (const DeclTypeSpec * type{GetImplicitType(symbol)}) {
       symbol.set(Symbol::Flag::Implicit);
       symbol.SetType(*type);
     } else if (symbol.has<ProcEntityDetails>() &&
         !symbol.attrs().test(Attr::EXTERNAL) && IsIntrinsic(symbol.name())) {
       // type will be determined in expression semantics
       symbol.attrs().set(Attr::INTRINSIC);
     } else if (!context().HasError(symbol)) {
       Say(symbol.name(), "No explicit type declared for '%s'"_err_en_US);
       context().SetError(symbol);
     }
   }
 }
 
 const DeclTypeSpec *ScopeHandler::GetImplicitType(Symbol &symbol) {
   const DeclTypeSpec *type{implicitRules().GetType(symbol.name().begin()[0])};
   if (type) {
     if (const DerivedTypeSpec * derived{type->AsDerived()}) {
       // Resolve any forward-referenced derived type; a quick no-op else.
       auto &instantiatable{*const_cast<DerivedTypeSpec *>(derived)};
       instantiatable.Instantiate(currScope(), context());
     }
   }
   return type;
 }
 
 // Convert symbol to be a ObjectEntity or return false if it can't be.
 bool ScopeHandler::ConvertToObjectEntity(Symbol &symbol) {
   if (symbol.has<ObjectEntityDetails>()) {
     // nothing to do
   } else if (symbol.has<UnknownDetails>()) {
     symbol.set_details(ObjectEntityDetails{});
   } else if (auto *details{symbol.detailsIf<EntityDetails>()}) {
     symbol.set_details(ObjectEntityDetails{std::move(*details)});
   } else if (auto *useDetails{symbol.detailsIf<UseDetails>()}) {
     return useDetails->symbol().has<ObjectEntityDetails>();
   } else {
     return false;
   }
   return true;
 }
 // Convert symbol to be a ProcEntity or return false if it can't be.
 bool ScopeHandler::ConvertToProcEntity(Symbol &symbol) {
   if (symbol.has<ProcEntityDetails>()) {
     // nothing to do
   } else if (symbol.has<UnknownDetails>()) {
     symbol.set_details(ProcEntityDetails{});
   } else if (auto *details{symbol.detailsIf<EntityDetails>()}) {
     symbol.set_details(ProcEntityDetails{std::move(*details)});
     if (symbol.GetType() && !symbol.test(Symbol::Flag::Implicit)) {
       CHECK(!symbol.test(Symbol::Flag::Subroutine));
       symbol.set(Symbol::Flag::Function);
     }
   } else {
     return false;
   }
   return true;
 }
 
 const DeclTypeSpec &ScopeHandler::MakeNumericType(
     TypeCategory category, const std::optional<parser::KindSelector> &kind) {
   KindExpr value{GetKindParamExpr(category, kind)};
   if (auto known{evaluate::ToInt64(value)}) {
     return context().MakeNumericType(category, static_cast<int>(*known));
   } else {
     return currScope_->MakeNumericType(category, std::move(value));
   }
 }
 
 const DeclTypeSpec &ScopeHandler::MakeLogicalType(
     const std::optional<parser::KindSelector> &kind) {
   KindExpr value{GetKindParamExpr(TypeCategory::Logical, kind)};
   if (auto known{evaluate::ToInt64(value)}) {
     return context().MakeLogicalType(static_cast<int>(*known));
   } else {
     return currScope_->MakeLogicalType(std::move(value));
   }
 }
 
 void ScopeHandler::MakeExternal(Symbol &symbol) {
   if (!symbol.attrs().test(Attr::EXTERNAL)) {
     symbol.attrs().set(Attr::EXTERNAL);
     if (symbol.attrs().test(Attr::INTRINSIC)) { // C840
       Say(symbol.name(),
           "Symbol '%s' cannot have both EXTERNAL and INTRINSIC attributes"_err_en_US,
           symbol.name());
     }
   }
 }
 
 // ModuleVisitor implementation
 
 bool ModuleVisitor::Pre(const parser::Only &x) {
   std::visit(common::visitors{
                  [&](const Indirection<parser::GenericSpec> &generic) {
                    AddUse(GenericSpecInfo{generic.value()});
                  },
                  [&](const parser::Name &name) {
                    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)};
   SymbolRename rename{AddUse(localName.source, useName.source)};
   Resolve(useName, rename.use);
   Resolve(localName, rename.local);
   return false;
 }
 bool ModuleVisitor::Pre(const parser::Rename::Operators &x) {
   const parser::DefinedOpName &local{std::get<0>(x.t)};
   const parser::DefinedOpName &use{std::get<1>(x.t)};
   GenericSpecInfo localInfo{local};
   GenericSpecInfo useInfo{use};
   if (IsIntrinsicOperator(context(), local.v.source)) {
     Say(local.v,
         "Intrinsic operator '%s' may not be used as a defined operator"_err_en_US);
   } else if (IsLogicalConstant(context(), local.v.source)) {
     Say(local.v,
         "Logical constant '%s' may not be used as a defined operator"_err_en_US);
   } else {
     SymbolRename rename{AddUse(localInfo.symbolName(), useInfo.symbolName())};
     useInfo.Resolve(rename.use);
     localInfo.Resolve(rename.local);
   }
   return false;
 }
 
 // Set useModuleScope_ to the Scope of the module being used.
 bool ModuleVisitor::Pre(const parser::UseStmt &x) {
   useModuleScope_ = FindModule(x.moduleName);
   return useModuleScope_ != nullptr;
 }
 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{
                      [&](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) &&
           !symbol->attrs().test(Attr::INTRINSIC) &&
           !symbol->detailsIf<MiscDetails>()) {
         if (useNames.count(name) == 0) {
           auto *localSymbol{FindInScope(currScope(), name)};
           if (!localSymbol) {
             localSymbol = &CopySymbol(name, *symbol);
           }
           AddUse(x.moduleName.source, *localSymbol, *symbol);
         }
       }
     }
   }
   useModuleScope_ = nullptr;
 }
 
 ModuleVisitor::SymbolRename ModuleVisitor::AddUse(
     const SourceName &localName, const SourceName &useName) {
   return AddUse(localName, useName, FindInScope(*useModuleScope_, useName));
 }
 
 ModuleVisitor::SymbolRename ModuleVisitor::AddUse(
     const SourceName &localName, const SourceName &useName, Symbol *useSymbol) {
   if (!useModuleScope_) {
     return {}; // error occurred finding module
   }
   if (!useSymbol) {
     Say(useName,
         IsDefinedOperator(useName)
             ? "Operator '%s' not found in module '%s'"_err_en_US
             : "'%s' not found in module '%s'"_err_en_US,
         useName, useModuleScope_->GetName().value());
     return {};
   }
   if (useSymbol->attrs().test(Attr::PRIVATE)) {
     Say(useName,
         IsDefinedOperator(useName)
             ? "Operator '%s' is PRIVATE in '%s'"_err_en_US
             : "'%s' is PRIVATE in '%s'"_err_en_US,
         useName, useModuleScope_->GetName().value());
     return {};
   }
   auto &localSymbol{MakeSymbol(localName)};
   AddUse(useName, localSymbol, *useSymbol);
   return {&localSymbol, useSymbol};
 }
 
 // symbol must be either a Use or a Generic formed by merging two uses.
 // Convert it to a UseError with this additional location.
 static void ConvertToUseError(
     Symbol &symbol, const SourceName &location, const Scope &module) {
   const auto *useDetails{symbol.detailsIf<UseDetails>()};
   if (!useDetails) {
     auto &genericDetails{symbol.get<GenericDetails>()};
     useDetails = &genericDetails.useDetails().value();
   }
   symbol.set_details(
       UseErrorDetails{*useDetails}.add_occurrence(location, module));
 }
 
 void ModuleVisitor::AddUse(
     const SourceName &location, Symbol &localSymbol, const Symbol &useSymbol) {
   localSymbol.attrs() = useSymbol.attrs() & ~Attrs{Attr::PUBLIC, Attr::PRIVATE};
   localSymbol.flags() = useSymbol.flags();
   if (auto *useDetails{localSymbol.detailsIf<UseDetails>()}) {
     const Symbol &ultimate{localSymbol.GetUltimate()};
     if (ultimate == useSymbol.GetUltimate()) {
       // use-associating the same symbol again -- ok
     } else if (ultimate.has<GenericDetails>() &&
         useSymbol.has<GenericDetails>()) {
       // use-associating generics with the same names: merge them into a
       // new generic in this scope
       auto generic1{ultimate.get<GenericDetails>()};
       generic1.set_useDetails(*useDetails);
       // useSymbol has specific g and so does generic1
       auto &generic2{useSymbol.get<GenericDetails>()};
       if (generic1.specific() && generic2.specific() &&
           generic1.specific() != generic2.specific()) {
         Say(location,
             "Generic interface '%s' has ambiguous specific procedures"
             " from modules '%s' and '%s'"_err_en_US,
             localSymbol.name(), GetUsedModule(*useDetails).name(),
             useSymbol.owner().GetName().value());
       } else if (generic1.derivedType() && generic2.derivedType() &&
           generic1.derivedType() != generic2.derivedType()) {
         Say(location,
             "Generic interface '%s' has ambiguous derived types"
             " from modules '%s' and '%s'"_err_en_US,
             localSymbol.name(), GetUsedModule(*useDetails).name(),
             useSymbol.owner().GetName().value());
       } else {
         generic1.CopyFrom(generic2);
       }
       EraseSymbol(localSymbol);
       MakeSymbol(localSymbol.name(), ultimate.attrs(), std::move(generic1));
     } else {
       ConvertToUseError(localSymbol, location, *useModuleScope_);
     }
   } else {
     auto *genericDetails{localSymbol.detailsIf<GenericDetails>()};
     if (genericDetails && genericDetails->useDetails()) {
       // localSymbol came from merging two use-associated generics
       if (auto *useDetails{useSymbol.detailsIf<GenericDetails>()}) {
         genericDetails->CopyFrom(*useDetails);
       } else {
         ConvertToUseError(localSymbol, location, *useModuleScope_);
       }
     } else if (auto *details{localSymbol.detailsIf<UseErrorDetails>()}) {
       details->add_occurrence(location, *useModuleScope_);
     } else if (!localSymbol.has<UnknownDetails>()) {
       Say(location,
           "Cannot use-associate '%s'; it is already declared in this scope"_err_en_US,
           localSymbol.name())
           .Attach(localSymbol.name(), "Previous declaration of '%s'"_en_US,
               localSymbol.name());
     } else {
       localSymbol.set_details(UseDetails{location, useSymbol});
     }
   }
 }
 
 void ModuleVisitor::AddUse(const GenericSpecInfo &info) {
   if (useModuleScope_) {
     const auto &name{info.symbolName()};
     auto rename{
         AddUse(name, name, info.FindInScope(context(), *useModuleScope_))};
     info.Resolve(rename.use);
   }
 }
 
 bool ModuleVisitor::BeginSubmodule(
     const parser::Name &name, const parser::ParentIdentifier &parentId) {
   auto &ancestorName{std::get<parser::Name>(parentId.t)};
   auto &parentName{std::get<std::optional<parser::Name>>(parentId.t)};
   Scope *ancestor{FindModule(ancestorName)};
   if (!ancestor) {
     return false;
   }
   Scope *parentScope{parentName ? FindModule(*parentName, ancestor) : ancestor};
   if (!parentScope) {
     return false;
   }
   PushScope(*parentScope); // submodule is hosted in parent
   BeginModule(name, true);
   if (!ancestor->AddSubmodule(name.source, currScope())) {
     Say(name, "Module '%s' already has a submodule named '%s'"_err_en_US,
         ancestorName.source, name.source);
   }
   return true;
 }
 
 void ModuleVisitor::BeginModule(const parser::Name &name, bool isSubmodule) {
   auto &symbol{MakeSymbol(name, ModuleDetails{isSubmodule})};
   auto &details{symbol.get<ModuleDetails>()};
   PushScope(Scope::Kind::Module, &symbol);
   details.set_scope(&currScope());
   defaultAccess_ = Attr::PUBLIC;
   prevAccessStmt_ = std::nullopt;
 }
 
 // Find a module or submodule by name and return its scope.
 // If ancestor is present, look for a submodule of that ancestor module.
 // May have to read a .mod file to find it.
 // If an error occurs, report it and return nullptr.
 Scope *ModuleVisitor::FindModule(const parser::Name &name, Scope *ancestor) {
   ModFileReader reader{context()};
   Scope *scope{reader.Read(name.source, ancestor)};
   if (!scope) {
     return nullptr;
   }
   if (scope->kind() != Scope::Kind::Module) {
     Say(name, "'%s' is not a module"_err_en_US);
     return nullptr;
   }
   if (DoesScopeContain(scope, currScope())) { // 14.2.2(1)
     Say(name, "Module '%s' cannot USE itself"_err_en_US);
   }
   Resolve(name, scope->symbol());
   return scope;
 }
 
 void ModuleVisitor::ApplyDefaultAccess() {
   for (auto &pair : currScope()) {
     Symbol &symbol = *pair.second;
     if (!symbol.attrs().HasAny({Attr::PUBLIC, Attr::PRIVATE})) {
       symbol.attrs().set(defaultAccess_);
     }
   }
 }
 
 // InterfaceVistor implementation
 
 bool InterfaceVisitor::Pre(const parser::InterfaceStmt &x) {
   bool isAbstract{std::holds_alternative<parser::Abstract>(x.u)};
   genericInfo_.emplace(/*isInterface*/ true, isAbstract);
   return BeginAttrs();
 }
 
 void InterfaceVisitor::Post(const parser::InterfaceStmt &) { EndAttrs(); }
 
 void InterfaceVisitor::Post(const parser::EndInterfaceStmt &) {
   genericInfo_.pop();
 }
 
 // Create a symbol in genericSymbol_ for this GenericSpec.
 bool InterfaceVisitor::Pre(const parser::GenericSpec &x) {
   if (auto *symbol{GenericSpecInfo{x}.FindInScope(context(), currScope())}) {
     SetGenericSymbol(*symbol);
   }
   return false;
 }
 
 bool InterfaceVisitor::Pre(const parser::ProcedureStmt &x) {
   if (!isGeneric()) {
     Say("A PROCEDURE statement is only allowed in a generic interface block"_err_en_US);
     return false;
   }
   auto kind{std::get<parser::ProcedureStmt::Kind>(x.t)};
   const auto &names{std::get<std::list<parser::Name>>(x.t)};
   AddSpecificProcs(names, kind);
   return false;
 }
 
 bool InterfaceVisitor::Pre(const parser::GenericStmt &) {
   genericInfo_.emplace(/*isInterface*/ false);
   return true;
 }
 void InterfaceVisitor::Post(const parser::GenericStmt &x) {
   if (auto &accessSpec{std::get<std::optional<parser::AccessSpec>>(x.t)}) {
     GetGenericInfo().symbol->attrs().set(AccessSpecToAttr(*accessSpec));
   }
   const auto &names{std::get<std::list<parser::Name>>(x.t)};
   AddSpecificProcs(names, ProcedureKind::Procedure);
   genericInfo_.pop();
 }
 
 bool InterfaceVisitor::inInterfaceBlock() const {
   return !genericInfo_.empty() && GetGenericInfo().isInterface;
 }
 bool InterfaceVisitor::isGeneric() const {
   return !genericInfo_.empty() && GetGenericInfo().symbol;
 }
 bool InterfaceVisitor::isAbstract() const {
   return !genericInfo_.empty() && GetGenericInfo().isAbstract;
 }
 GenericDetails &InterfaceVisitor::GetGenericDetails() {
   return GetGenericInfo().symbol->get<GenericDetails>();
 }
 
 void InterfaceVisitor::AddSpecificProcs(
     const std::list<parser::Name> &names, ProcedureKind kind) {
   for (const auto &name : names) {
     specificProcs_.emplace(
         GetGenericInfo().symbol, std::make_pair(&name, kind));
   }
 }
 
 // By now we should have seen all specific procedures referenced by name in
 // this generic interface. Resolve those names to symbols.
 void InterfaceVisitor::ResolveSpecificsInGeneric(Symbol &generic) {
   auto &details{generic.get<GenericDetails>()};
   std::set<SourceName> namesSeen; // to check for duplicate names
   for (const Symbol &symbol : details.specificProcs()) {
     namesSeen.insert(symbol.name());
   }
   auto range{specificProcs_.equal_range(&generic)};
   for (auto it{range.first}; it != range.second; ++it) {
     auto *name{it->second.first};
     auto kind{it->second.second};
     const auto *symbol{FindSymbol(*name)};
     if (!symbol) {
       Say(*name, "Procedure '%s' not found"_err_en_US);
       continue;
     }
     symbol = &symbol->GetUltimate();
     if (symbol == &generic) {
       if (auto *specific{generic.get<GenericDetails>().specific()}) {
         symbol = specific;
       }
     }
     if (!symbol->has<SubprogramDetails>() &&
         !symbol->has<SubprogramNameDetails>()) {
       Say(*name, "'%s' is not a subprogram"_err_en_US);
       continue;
     }
     if (kind == ProcedureKind::ModuleProcedure) {
       if (const auto *nd{symbol->detailsIf<SubprogramNameDetails>()}) {
         if (nd->kind() != SubprogramKind::Module) {
           Say(*name, "'%s' is not a module procedure"_err_en_US);
         }
       } else {
         // USE-associated procedure
         const auto *sd{symbol->detailsIf<SubprogramDetails>()};
         CHECK(sd);
         if (symbol->owner().kind() != Scope::Kind::Module ||
             sd->isInterface()) {
           Say(*name, "'%s' is not a module procedure"_err_en_US);
         }
       }
     }
     if (!namesSeen.insert(name->source).second) {
       Say(*name,
           details.kind().IsDefinedOperator()
               ? "Procedure '%s' is already specified in generic operator '%s'"_err_en_US
               : "Procedure '%s' is already specified in generic '%s'"_err_en_US,
           name->source, generic.name());
       continue;
     }
     details.AddSpecificProc(*symbol, name->source);
   }
   specificProcs_.erase(range.first, range.second);
 }
 
 // Check that the specific procedures are all functions or all subroutines.
 // If there is a derived type with the same name they must be functions.
 // Set the corresponding flag on generic.
 void InterfaceVisitor::CheckGenericProcedures(Symbol &generic) {
   ResolveSpecificsInGeneric(generic);
   auto &details{generic.get<GenericDetails>()};
   if (auto *proc{details.CheckSpecific()}) {
     auto msg{
         "'%s' may not be the name of both a generic interface and a"
         " procedure unless it is a specific procedure of the generic"_err_en_US};
     if (proc->name().begin() > generic.name().begin()) {
       Say(proc->name(), std::move(msg));
     } else {
       Say(generic.name(), std::move(msg));
     }
   }
   auto &specifics{details.specificProcs()};
   if (specifics.empty()) {
     if (details.derivedType()) {
       generic.set(Symbol::Flag::Function);
     }
     return;
   }
   const Symbol &firstSpecific{specifics.front()};
   bool isFunction{firstSpecific.test(Symbol::Flag::Function)};
   for (const Symbol &specific : specifics) {
     if (isFunction != specific.test(Symbol::Flag::Function)) { // C1514
       auto &msg{Say(generic.name(),
           "Generic interface '%s' has both a function and a subroutine"_err_en_US)};
       if (isFunction) {
         msg.Attach(firstSpecific.name(), "Function declaration"_en_US);
         msg.Attach(specific.name(), "Subroutine declaration"_en_US);
       } else {
         msg.Attach(firstSpecific.name(), "Subroutine declaration"_en_US);
         msg.Attach(specific.name(), "Function declaration"_en_US);
       }
     }
   }
   if (!isFunction && details.derivedType()) {
     SayDerivedType(generic.name(),
         "Generic interface '%s' may only contain functions due to derived type"
         " with same name"_err_en_US,
         *details.derivedType()->scope());
   }
   generic.set(isFunction ? Symbol::Flag::Function : Symbol::Flag::Subroutine);
 }
 
 // SubprogramVisitor implementation
 
 // Return false if it is actually an assignment statement.
 bool SubprogramVisitor::HandleStmtFunction(const parser::StmtFunctionStmt &x) {
   const auto &name{std::get<parser::Name>(x.t)};
   const DeclTypeSpec *resultType{nullptr};
   // Look up name: provides return type or tells us if it's an array
   if (auto *symbol{FindSymbol(name)}) {
     auto *details{symbol->detailsIf<EntityDetails>()};
     if (!details) {
       badStmtFuncFound_ = true;
       return false;
     }
     // TODO: check that attrs are compatible with stmt func
     resultType = details->type();
     symbol->details() = UnknownDetails{}; // will be replaced below
   }
   if (badStmtFuncFound_) {
     Say(name, "'%s' has not been declared as an array"_err_en_US);
     return true;
   }
   auto &symbol{PushSubprogramScope(name, Symbol::Flag::Function)};
   symbol.set(Symbol::Flag::StmtFunction);
   EraseSymbol(symbol); // removes symbol added by PushSubprogramScope
   auto &details{symbol.get<SubprogramDetails>()};
   for (const auto &dummyName : std::get<std::list<parser::Name>>(x.t)) {
     ObjectEntityDetails dummyDetails{true};
     if (auto *dummySymbol{FindInScope(currScope().parent(), dummyName)}) {
       if (auto *d{dummySymbol->detailsIf<EntityDetails>()}) {
         if (d->type()) {
           dummyDetails.set_type(*d->type());
         }
       }
     }
     Symbol &dummy{MakeSymbol(dummyName, std::move(dummyDetails))};
     ApplyImplicitRules(dummy);
     details.add_dummyArg(dummy);
   }
   ObjectEntityDetails resultDetails;
   if (resultType) {
     resultDetails.set_type(*resultType);
   }
   resultDetails.set_funcResult(true);
   Symbol &result{MakeSymbol(name, std::move(resultDetails))};
   ApplyImplicitRules(result);
   details.set_result(result);
   const auto &parsedExpr{std::get<parser::Scalar<parser::Expr>>(x.t)};
   Walk(parsedExpr);
   // The analysis of the expression that constitutes the body of the
   // statement function is deferred to FinishSpecificationPart() so that
   // all declarations and implicit typing are complete.
   PopScope();
   return true;
 }
 
 bool SubprogramVisitor::Pre(const parser::Suffix &suffix) {
   if (suffix.resultName) {
     funcInfo_.resultName = &suffix.resultName.value();
   }
   return true;
 }
 
 bool SubprogramVisitor::Pre(const parser::PrefixSpec &x) {
   // Save this to process after UseStmt and ImplicitPart
   if (const auto *parsedType{std::get_if<parser::DeclarationTypeSpec>(&x.u)}) {
     if (funcInfo_.parsedType) { // C1543
       Say(currStmtSource().value(),
           "FUNCTION prefix cannot specify the type more than once"_err_en_US);
       return false;
     } else {
       funcInfo_.parsedType = parsedType;
       funcInfo_.source = currStmtSource();
       return false;
     }
   } else {
     return true;
   }
 }
 
 void SubprogramVisitor::Post(const parser::ImplicitPart &) {
   // If the function has a type in the prefix, process it now
   if (funcInfo_.parsedType) {
     messageHandler().set_currStmtSource(funcInfo_.source);
     if (const auto *type{ProcessTypeSpec(*funcInfo_.parsedType, true)}) {
       funcInfo_.resultSymbol->SetType(*type);
     }
   }
   funcInfo_ = {};
 }
 
 bool SubprogramVisitor::Pre(const parser::InterfaceBody::Subroutine &x) {
   const auto &name{std::get<parser::Name>(
       std::get<parser::Statement<parser::SubroutineStmt>>(x.t).statement.t)};
   return BeginSubprogram(name, Symbol::Flag::Subroutine);
 }
 void SubprogramVisitor::Post(const parser::InterfaceBody::Subroutine &) {
   EndSubprogram();
 }
 bool SubprogramVisitor::Pre(const parser::InterfaceBody::Function &x) {
   const auto &name{std::get<parser::Name>(
       std::get<parser::Statement<parser::FunctionStmt>>(x.t).statement.t)};
   return BeginSubprogram(name, Symbol::Flag::Function);
 }
 void SubprogramVisitor::Post(const parser::InterfaceBody::Function &) {
   EndSubprogram();
 }
 
 bool SubprogramVisitor::Pre(const parser::SubroutineStmt &) {
   return BeginAttrs();
 }
 bool SubprogramVisitor::Pre(const parser::FunctionStmt &) {
   return BeginAttrs();
 }
 bool SubprogramVisitor::Pre(const parser::EntryStmt &) { return BeginAttrs(); }
 
 void SubprogramVisitor::Post(const parser::SubroutineStmt &stmt) {
   const auto &name{std::get<parser::Name>(stmt.t)};
   auto &details{PostSubprogramStmt(name)};
   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{MakeSymbol(*dummyName, EntityDetails(true))};
       details.add_dummyArg(dummy);
     } else {
       details.add_alternateReturn();
     }
   }
 }
 
 void SubprogramVisitor::Post(const parser::FunctionStmt &stmt) {
   const auto &name{std::get<parser::Name>(stmt.t)};
   auto &details{PostSubprogramStmt(name)};
   for (const auto &dummyName : std::get<std::list<parser::Name>>(stmt.t)) {
     Symbol &dummy{MakeSymbol(dummyName, EntityDetails(true))};
     details.add_dummyArg(dummy);
   }
   const parser::Name *funcResultName;
   if (funcInfo_.resultName && funcInfo_.resultName->source != name.source) {
     // Note that RESULT is ignored if it has the same name as the function.
     funcResultName = funcInfo_.resultName;
   } else {
     EraseSymbol(name); // was added by PushSubprogramScope
     funcResultName = &name;
   }
   // add function result to function scope
   EntityDetails funcResultDetails;
   funcResultDetails.set_funcResult(true);
   funcInfo_.resultSymbol =
       &MakeSymbol(*funcResultName, std::move(funcResultDetails));
   details.set_result(*funcInfo_.resultSymbol);
 
   // C1560.
   if (funcInfo_.resultName && funcInfo_.resultName->source == name.source) {
     Say(funcInfo_.resultName->source,
         "The function name should not appear in RESULT, references to '%s' "
         "inside"
         " the function will be considered as references to the result only"_en_US,
         name.source);
     // RESULT name was ignored above, the only side effect from doing so will be
     // the inability to make recursive calls. The related parser::Name is still
     // resolved to the created function result symbol because every parser::Name
     // should be resolved to avoid internal errors.
     Resolve(*funcInfo_.resultName, funcInfo_.resultSymbol);
   }
   name.symbol = currScope().symbol(); // must not be function result symbol
   // Clear the RESULT() name now in case an ENTRY statement in the implicit-part
   // has a RESULT() suffix.
   funcInfo_.resultName = nullptr;
 }
 
 SubprogramDetails &SubprogramVisitor::PostSubprogramStmt(
     const parser::Name &name) {
   Symbol &symbol{*currScope().symbol()};
   CHECK(name.source == symbol.name());
   SetBindNameOn(symbol);
   symbol.attrs() |= EndAttrs();
   if (symbol.attrs().test(Attr::MODULE)) {
     symbol.attrs().set(Attr::EXTERNAL, false);
   }
   return symbol.get<SubprogramDetails>();
 }
 
 void SubprogramVisitor::Post(const parser::EntryStmt &stmt) {
   auto attrs{EndAttrs()}; // needs to be called even if early return
   Scope &inclusiveScope{InclusiveScope()};
   const Symbol *subprogram{inclusiveScope.symbol()};
   if (!subprogram) {
     CHECK(context().AnyFatalError());
     return;
   }
   const auto &name{std::get<parser::Name>(stmt.t)};
   const auto *parentDetails{subprogram->detailsIf<SubprogramDetails>()};
   bool inFunction{parentDetails && parentDetails->isFunction()};
   const parser::Name *resultName{funcInfo_.resultName};
   if (resultName) { // RESULT(result) is present
     funcInfo_.resultName = nullptr;
     if (!inFunction) {
       Say2(resultName->source,
           "RESULT(%s) may appear only in a function"_err_en_US,
           subprogram->name(), "Containing subprogram"_en_US);
     } else if (resultName->source == subprogram->name()) { // C1574
       Say2(resultName->source,
           "RESULT(%s) may not have the same name as the function"_err_en_US,
           subprogram->name(), "Containing function"_en_US);
     } else if (const Symbol *
         symbol{FindSymbol(inclusiveScope.parent(), *resultName)}) { // C1574
       if (const auto *details{symbol->detailsIf<SubprogramDetails>()}) {
         if (details->entryScope() == &inclusiveScope) {
           Say2(resultName->source,
               "RESULT(%s) may not have the same name as an ENTRY in the function"_err_en_US,
               symbol->name(), "Conflicting ENTRY"_en_US);
         }
       }
     }
     if (Symbol * symbol{FindSymbol(name)}) { // C1570
       // When RESULT() appears, ENTRY name can't have been already declared
       if (inclusiveScope.Contains(symbol->owner())) {
         Say2(name,
             "ENTRY name '%s' may not be declared when RESULT() is present"_err_en_US,
             *symbol, "Previous declaration of '%s'"_en_US);
       }
     }
     if (resultName->source == name.source) {
       // ignore RESULT() hereafter when it's the same name as the ENTRY
       resultName = nullptr;
     }
   }
   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::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);
               }},
           resultSymbol->details());
     } else if (inExecutionPart_) {
       ObjectEntityDetails entity;
       entity.set_funcResult(true);
       resultSymbol = &MakeSymbol(effectiveResultName, std::move(entity));
       ApplyImplicitRules(*resultSymbol);
     } else {
       EntityDetails entity;
       entity.set_funcResult(true);
       resultSymbol = &MakeSymbol(effectiveResultName, std::move(entity));
     }
     if (!resultName) {
       name.symbol = nullptr; // symbol will be used for entry point below
     }
     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::visitors{[](EntityDetails &x) { x.set_isDummy(); },
                 [](ObjectEntityDetails &x) { x.set_isDummy(); },
                 [](ProcEntityDetails &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);
                 }},
             dummy->details());
       } else {
         dummy = &MakeSymbol(*dummyName, EntityDetails(true));
       }
       entryDetails.add_dummyArg(*dummy);
     } else {
       if (inFunction) { // C1573
         Say(name,
             "ENTRY in a function may not have an alternate return dummy argument"_err_en_US);
         break;
       }
       entryDetails.add_alternateReturn();
     }
   }
 
   Symbol::Flag subpFlag{
       inFunction ? Symbol::Flag::Function : Symbol::Flag::Subroutine};
   CheckExtantExternal(name, subpFlag);
   Scope &outer{inclusiveScope.parent()}; // global or module scope
   if (Symbol * extant{FindSymbol(outer, name)}) {
     if (extant->has<ProcEntityDetails>()) {
       if (!extant->test(subpFlag)) {
         Say2(name,
             subpFlag == Symbol::Flag::Function
                 ? "'%s' was previously called as a subroutine"_err_en_US
                 : "'%s' was previously called as a function"_err_en_US,
             *extant, "Previous call of '%s'"_en_US);
       }
       if (extant->attrs().test(Attr::PRIVATE)) {
         attrs.set(Attr::PRIVATE);
       }
       outer.erase(extant->name());
     } else {
       if (outer.IsGlobal()) {
         Say2(name, "'%s' is already defined as a global identifier"_err_en_US,
             *extant, "Previous definition of '%s'"_en_US);
       } else {
         SayAlreadyDeclared(name, *extant);
       }
       return;
     }
   }
   if (outer.IsModule() && !attrs.test(Attr::PRIVATE)) {
     attrs.set(Attr::PUBLIC);
   }
   Symbol &entrySymbol{MakeSymbol(outer, name.source, attrs)};
   entrySymbol.set_details(std::move(entryDetails));
   if (outer.IsGlobal()) {
     MakeExternal(entrySymbol);
   }
   SetBindNameOn(entrySymbol);
   entrySymbol.set(subpFlag);
   Resolve(name, entrySymbol);
 }
 
 // A subprogram declared with MODULE PROCEDURE
 bool SubprogramVisitor::BeginMpSubprogram(const parser::Name &name) {
   auto *symbol{FindSymbol(name)};
   if (symbol && symbol->has<SubprogramNameDetails>()) {
     symbol = FindSymbol(currScope().parent(), name);
   }
   if (!IsSeparateModuleProcedureInterface(symbol)) {
     Say(name, "'%s' was not declared a separate module procedure"_err_en_US);
     return false;
   }
   if (symbol->owner() == currScope()) {
     PushScope(Scope::Kind::Subprogram, symbol);
   } else {
     Symbol &newSymbol{MakeSymbol(name, SubprogramDetails{})};
     PushScope(Scope::Kind::Subprogram, &newSymbol);
     const auto &details{symbol->get<SubprogramDetails>()};
     auto &newDetails{newSymbol.get<SubprogramDetails>()};
     for (const Symbol *dummyArg : details.dummyArgs()) {
       if (!dummyArg) {
         newDetails.add_alternateReturn();
       } else if (Symbol * copy{currScope().CopySymbol(*dummyArg)}) {
         newDetails.add_dummyArg(*copy);
       }
     }
     if (details.isFunction()) {
       currScope().erase(symbol->name());
       newDetails.set_result(*currScope().CopySymbol(details.result()));
     }
   }
   return true;
 }
 
 // A subprogram declared with SUBROUTINE or FUNCTION
 bool SubprogramVisitor::BeginSubprogram(
     const parser::Name &name, Symbol::Flag subpFlag, bool hasModulePrefix) {
   if (hasModulePrefix && !inInterfaceBlock() &&
       !IsSeparateModuleProcedureInterface(
           FindSymbol(currScope().parent(), name))) {
     Say(name, "'%s' was not declared a separate module procedure"_err_en_US);
     return false;
   }
   PushSubprogramScope(name, subpFlag);
   return true;
 }
 
 void SubprogramVisitor::EndSubprogram() { PopScope(); }
 
 void SubprogramVisitor::CheckExtantExternal(
     const parser::Name &name, Symbol::Flag subpFlag) {
   if (auto *prev{FindSymbol(name)}) {
     if (prev->attrs().test(Attr::EXTERNAL) && prev->has<ProcEntityDetails>()) {
       // this subprogram was previously called, now being declared
       if (!prev->test(subpFlag)) {
         Say2(name,
             subpFlag == Symbol::Flag::Function
                 ? "'%s' was previously called as a subroutine"_err_en_US
                 : "'%s' was previously called as a function"_err_en_US,
             *prev, "Previous call of '%s'"_en_US);
       }
       EraseSymbol(name);
     }
   }
 }
 
 Symbol &SubprogramVisitor::PushSubprogramScope(
     const parser::Name &name, Symbol::Flag subpFlag) {
   auto *symbol{GetSpecificFromGeneric(name)};
   if (!symbol) {
     CheckExtantExternal(name, subpFlag);
     symbol = &MakeSymbol(name, SubprogramDetails{});
   }
   symbol->set(subpFlag);
   PushScope(Scope::Kind::Subprogram, symbol);
   auto &details{symbol->get<SubprogramDetails>()};
   if (inInterfaceBlock()) {
     details.set_isInterface();
     if (!isAbstract()) {
       MakeExternal(*symbol);
     }
     if (isGeneric()) {
       GetGenericDetails().AddSpecificProc(*symbol, name.source);
     }
     implicitRules().set_inheritFromParent(false);
   }
   FindSymbol(name)->set(subpFlag); // PushScope() created symbol
   return *symbol;
 }
 
 void SubprogramVisitor::PushBlockDataScope(const parser::Name &name) {
   if (auto *prev{FindSymbol(name)}) {
     if (prev->attrs().test(Attr::EXTERNAL) && prev->has<ProcEntityDetails>()) {
       if (prev->test(Symbol::Flag::Subroutine) ||
           prev->test(Symbol::Flag::Function)) {
         Say2(name, "BLOCK DATA '%s' has been called"_err_en_US, *prev,
             "Previous call of '%s'"_en_US);
       }
       EraseSymbol(name);
     }
   }
   if (name.source.empty()) {
     // Don't let unnamed BLOCK DATA conflict with unnamed PROGRAM
     PushScope(Scope::Kind::BlockData, nullptr);
   } else {
     PushScope(Scope::Kind::BlockData, &MakeSymbol(name, SubprogramDetails{}));
   }
 }
 
 // If name is a generic, return specific subprogram with the same name.
 Symbol *SubprogramVisitor::GetSpecificFromGeneric(const parser::Name &name) {
   if (auto *symbol{FindSymbol(name)}) {
     if (auto *details{symbol->detailsIf<GenericDetails>()}) {
       // found generic, want subprogram
       auto *specific{details->specific()};
       if (!specific) {
         specific =
             &currScope().MakeSymbol(name.source, Attrs{}, SubprogramDetails{});
         details->set_specific(Resolve(name, *specific));
       } else if (isGeneric()) {
         SayAlreadyDeclared(name, *specific);
       } else if (!specific->has<SubprogramDetails>()) {
         specific->set_details(SubprogramDetails{});
       }
       return specific;
     }
   }
   return nullptr;
 }
 
 // DeclarationVisitor implementation
 
 bool DeclarationVisitor::BeginDecl() {
   BeginDeclTypeSpec();
   BeginArraySpec();
   return BeginAttrs();
 }
 void DeclarationVisitor::EndDecl() {
   EndDeclTypeSpec();
   EndArraySpec();
   EndAttrs();
 }
 
 bool DeclarationVisitor::CheckUseError(const parser::Name &name) {
   const auto *details{name.symbol->detailsIf<UseErrorDetails>()};
   if (!details) {
     return false;
   }
   Message &msg{Say(name, "Reference to '%s' is ambiguous"_err_en_US)};
   for (const auto &[location, module] : details->occurrences()) {
     msg.Attach(location, "'%s' was use-associated from module '%s'"_en_US,
         name.source, module->GetName().value());
   }
   return true;
 }
 
 // Report error if accessibility of symbol doesn't match isPrivate.
 void DeclarationVisitor::CheckAccessibility(
     const SourceName &name, bool isPrivate, Symbol &symbol) {
   if (symbol.attrs().test(Attr::PRIVATE) != isPrivate) {
     Say2(name,
         "'%s' does not have the same accessibility as its previous declaration"_err_en_US,
         symbol, "Previous declaration of '%s'"_en_US);
   }
 }
 
 void DeclarationVisitor::Post(const parser::TypeDeclarationStmt &) {
   if (!GetAttrs().HasAny({Attr::POINTER, Attr::ALLOCATABLE})) { // C702
     if (const auto *typeSpec{GetDeclTypeSpec()}) {
       if (typeSpec->category() == DeclTypeSpec::Character) {
         if (typeSpec->characterTypeSpec().length().isDeferred()) {
           Say("The type parameter LEN cannot be deferred without"
               " the POINTER or ALLOCATABLE attribute"_err_en_US);
         }
       } else if (const DerivedTypeSpec * derivedSpec{typeSpec->AsDerived()}) {
         for (const auto &pair : derivedSpec->parameters()) {
           if (pair.second.isDeferred()) {
             Say(currStmtSource().value(),
                 "The value of type parameter '%s' cannot be deferred"
                 " without the POINTER or ALLOCATABLE attribute"_err_en_US,
                 pair.first);
           }
         }
       }
     }
   }
   EndDecl();
 }
 
 void DeclarationVisitor::Post(const parser::DimensionStmt::Declaration &x) {
   const auto &name{std::get<parser::Name>(x.t)};
   DeclareObjectEntity(name, Attrs{});
 }
 void DeclarationVisitor::Post(const parser::CodimensionDecl &x) {
   const auto &name{std::get<parser::Name>(x.t)};
   DeclareObjectEntity(name, Attrs{});
 }
 
 bool DeclarationVisitor::Pre(const parser::Initialization &) {
   // Defer inspection of initializers to Initialization() so that the
   // symbol being initialized will be available within the initialization
   // expression.
   return false;
 }
 
 void DeclarationVisitor::Post(const parser::EntityDecl &x) {
   // TODO: may be under StructureStmt
   const auto &name{std::get<parser::ObjectName>(x.t)};
   Attrs attrs{attrs_ ? HandleSaveName(name.source, *attrs_) : Attrs{}};
   Symbol &symbol{DeclareUnknownEntity(name, attrs)};
   symbol.ReplaceName(name.source);
   if (auto &init{std::get<std::optional<parser::Initialization>>(x.t)}) {
     if (ConvertToObjectEntity(symbol)) {
       Initialization(name, *init, false);
     }
   } else if (attrs.test(Attr::PARAMETER)) { // C882, C883
     Say(name, "Missing initialization for parameter '%s'"_err_en_US);
   }
 }
 
 void DeclarationVisitor::Post(const parser::PointerDecl &x) {
   const auto &name{std::get<parser::Name>(x.t)};
   Symbol &symbol{DeclareUnknownEntity(name, Attrs{Attr::POINTER})};
   symbol.ReplaceName(name.source);
 }
 
 bool DeclarationVisitor::Pre(const parser::BindEntity &x) {
   auto kind{std::get<parser::BindEntity::Kind>(x.t)};
   auto &name{std::get<parser::Name>(x.t)};
   Symbol *symbol;
   if (kind == parser::BindEntity::Kind::Object) {
     symbol = &HandleAttributeStmt(Attr::BIND_C, name);
   } else {
     symbol = &MakeCommonBlockSymbol(name);
     symbol->attrs().set(Attr::BIND_C);
   }
   SetBindNameOn(*symbol);
   return false;
 }
 bool DeclarationVisitor::Pre(const parser::NamedConstantDef &x) {
   auto &name{std::get<parser::NamedConstant>(x.t).v};
   auto &symbol{HandleAttributeStmt(Attr::PARAMETER, name)};
   if (!ConvertToObjectEntity(symbol) ||
       symbol.test(Symbol::Flag::CrayPointer) ||
       symbol.test(Symbol::Flag::CrayPointee)) {
     SayWithDecl(
         name, symbol, "PARAMETER attribute not allowed on '%s'"_err_en_US);
     return false;
   }
   const auto &expr{std::get<parser::ConstantExpr>(x.t)};
   ApplyImplicitRules(symbol);
   Walk(expr);
   if (auto converted{
           EvaluateConvertedExpr(symbol, expr, expr.thing.value().source)}) {
     symbol.get<ObjectEntityDetails>().set_init(std::move(*converted));
   }
   return false;
 }
 bool DeclarationVisitor::Pre(const parser::NamedConstant &x) {
   const parser::Name &name{x.v};
   if (!FindSymbol(name)) {
     Say(name, "Named constant '%s' not found"_err_en_US);
   } else {
     CheckUseError(name);
   }
   return false;
 }
 
 bool DeclarationVisitor::Pre(const parser::Enumerator &enumerator) {
   const parser::Name &name{std::get<parser::NamedConstant>(enumerator.t).v};
   Symbol *symbol{FindSymbol(name)};
   if (symbol) {
     // Contrary to named constants appearing in a PARAMETER statement,
     // enumerator names should not have their type, dimension or any other
     // attributes defined before they are declared in the enumerator statement.
     // This is not explicitly forbidden by the standard, but they are scalars
     // which type is left for the compiler to chose, so do not let users try to
     // tamper with that.
     SayAlreadyDeclared(name, *symbol);
     symbol = nullptr;
   } else {
     // Enumerators are treated as PARAMETER (section 7.6 paragraph (4))
     symbol = &MakeSymbol(name, Attrs{Attr::PARAMETER}, ObjectEntityDetails{});
     symbol->SetType(context().MakeNumericType(
         TypeCategory::Integer, evaluate::CInteger::kind));
   }
 
   if (auto &init{std::get<std::optional<parser::ScalarIntConstantExpr>>(
           enumerator.t)}) {
     Walk(*init); // Resolve names in expression before evaluation.
     if (auto value{EvaluateInt64(context(), *init)}) {
       // Cast all init expressions to C_INT so that they can then be
       // safely incremented (see 7.6 Note 2).
       enumerationState_.value = static_cast<int>(*value);
     } else {
       Say(name,
           "Enumerator value could not be computed "
           "from the given expression"_err_en_US);
       // Prevent resolution of next enumerators value
       enumerationState_.value = std::nullopt;
     }
   }
 
   if (symbol) {
     if (enumerationState_.value) {
       symbol->get<ObjectEntityDetails>().set_init(SomeExpr{
           evaluate::Expr<evaluate::CInteger>{*enumerationState_.value}});
     } else {
       context().SetError(*symbol);
     }
   }
 
   if (enumerationState_.value) {
     (*enumerationState_.value)++;
   }
   return false;
 }
 
 void DeclarationVisitor::Post(const parser::EnumDef &) {
   enumerationState_ = EnumeratorState{};
 }
 
 bool DeclarationVisitor::Pre(const parser::AccessSpec &x) {
   Attr attr{AccessSpecToAttr(x)};
   if (!NonDerivedTypeScope().IsModule()) { // C817
     Say(currStmtSource().value(),
         "%s attribute may only appear in the specification part of a module"_err_en_US,
         EnumToString(attr));
   }
   CheckAndSet(attr);
   return false;
 }
 
 bool DeclarationVisitor::Pre(const parser::AsynchronousStmt &x) {
   return HandleAttributeStmt(Attr::ASYNCHRONOUS, x.v);
 }
 bool DeclarationVisitor::Pre(const parser::ContiguousStmt &x) {
   return HandleAttributeStmt(Attr::CONTIGUOUS, x.v);
 }
 bool DeclarationVisitor::Pre(const parser::ExternalStmt &x) {
   HandleAttributeStmt(Attr::EXTERNAL, x.v);
   for (const auto &name : x.v) {
     auto *symbol{FindSymbol(name)};
     if (!ConvertToProcEntity(*symbol)) {
       SayWithDecl(
           name, *symbol, "EXTERNAL attribute not allowed on '%s'"_err_en_US);
     }
   }
   return false;
 }
 bool DeclarationVisitor::Pre(const parser::IntentStmt &x) {
   auto &intentSpec{std::get<parser::IntentSpec>(x.t)};
   auto &names{std::get<std::list<parser::Name>>(x.t)};
   return CheckNotInBlock("INTENT") && // C1107
       HandleAttributeStmt(IntentSpecToAttr(intentSpec), names);
 }
 bool DeclarationVisitor::Pre(const parser::IntrinsicStmt &x) {
   HandleAttributeStmt(Attr::INTRINSIC, x.v);
   for (const auto &name : x.v) {
     auto *symbol{FindSymbol(name)};
     if (!ConvertToProcEntity(*symbol)) {
       SayWithDecl(
           name, *symbol, "INTRINSIC attribute not allowed on '%s'"_err_en_US);
     } else if (symbol->attrs().test(Attr::EXTERNAL)) { // C840
       Say(symbol->name(),
           "Symbol '%s' cannot have both EXTERNAL and INTRINSIC attributes"_err_en_US,
           symbol->name());
     }
   }
   return false;
 }
 bool DeclarationVisitor::Pre(const parser::OptionalStmt &x) {
   return CheckNotInBlock("OPTIONAL") && // C1107
       HandleAttributeStmt(Attr::OPTIONAL, x.v);
 }
 bool DeclarationVisitor::Pre(const parser::ProtectedStmt &x) {
   return HandleAttributeStmt(Attr::PROTECTED, x.v);
 }
 bool DeclarationVisitor::Pre(const parser::ValueStmt &x) {
   return CheckNotInBlock("VALUE") && // C1107
       HandleAttributeStmt(Attr::VALUE, x.v);
 }
 bool DeclarationVisitor::Pre(const parser::VolatileStmt &x) {
   return HandleAttributeStmt(Attr::VOLATILE, x.v);
 }
 // Handle a statement that sets an attribute on a list of names.
 bool DeclarationVisitor::HandleAttributeStmt(
     Attr attr, const std::list<parser::Name> &names) {
   for (const auto &name : names) {
     HandleAttributeStmt(attr, name);
   }
   return false;
 }
 Symbol &DeclarationVisitor::HandleAttributeStmt(
     Attr attr, const parser::Name &name) {
   if (attr == Attr::INTRINSIC && !IsIntrinsic(name.source)) {
     Say(name.source, "'%s' is not a known intrinsic procedure"_err_en_US);
   }
   auto *symbol{FindInScope(currScope(), name)};
   if (attr == Attr::ASYNCHRONOUS || attr == Attr::VOLATILE) {
     // these can be set on a symbol that is host-assoc or use-assoc
     if (!symbol &&
         (currScope().kind() == Scope::Kind::Subprogram ||
             currScope().kind() == Scope::Kind::Block)) {
       if (auto *hostSymbol{FindSymbol(name)}) {
         name.symbol = nullptr;
         symbol = &MakeSymbol(name, HostAssocDetails{*hostSymbol});
       }
     }
   } else if (symbol && symbol->has<UseDetails>()) {
     Say(currStmtSource().value(),
         "Cannot change %s attribute on use-associated '%s'"_err_en_US,
         EnumToString(attr), name.source);
     return *symbol;
   }
   if (!symbol) {
     symbol = &MakeSymbol(name, EntityDetails{});
   }
   symbol->attrs().set(attr);
   symbol->attrs() = HandleSaveName(name.source, symbol->attrs());
   return *symbol;
 }
 // C1107
 bool DeclarationVisitor::CheckNotInBlock(const char *stmt) {
   if (currScope().kind() == Scope::Kind::Block) {
     Say(MessageFormattedText{
         "%s statement is not allowed in a BLOCK construct"_err_en_US, stmt});
     return false;
   } else {
     return true;
   }
 }
 
 void DeclarationVisitor::Post(const parser::ObjectDecl &x) {
   CHECK(objectDeclAttr_);
   const auto &name{std::get<parser::ObjectName>(x.t)};
   DeclareObjectEntity(name, Attrs{*objectDeclAttr_});
 }
 
 // Declare an entity not yet known to be an object or proc.
 Symbol &DeclarationVisitor::DeclareUnknownEntity(
     const parser::Name &name, Attrs attrs) {
   if (!arraySpec().empty() || !coarraySpec().empty()) {
     return DeclareObjectEntity(name, attrs);
   } else {
     Symbol &symbol{DeclareEntity<EntityDetails>(name, attrs)};
     if (auto *type{GetDeclTypeSpec()}) {
       SetType(name, *type);
     }
     charInfo_.length.reset();
     SetBindNameOn(symbol);
     if (symbol.attrs().test(Attr::EXTERNAL)) {
       ConvertToProcEntity(symbol);
     }
     return symbol;
   }
 }
 
 Symbol &DeclarationVisitor::DeclareProcEntity(
     const parser::Name &name, Attrs attrs, const ProcInterface &interface) {
   Symbol &symbol{DeclareEntity<ProcEntityDetails>(name, attrs)};
   if (auto *details{symbol.detailsIf<ProcEntityDetails>()}) {
     if (details->IsInterfaceSet()) {
       SayWithDecl(name, symbol,
           "The interface for procedure '%s' has already been "
           "declared"_err_en_US);
       context().SetError(symbol);
     } else {
       if (interface.type()) {
         symbol.set(Symbol::Flag::Function);
       } else if (interface.symbol()) {
         if (interface.symbol()->test(Symbol::Flag::Function)) {
           symbol.set(Symbol::Flag::Function);
         } else if (interface.symbol()->test(Symbol::Flag::Subroutine)) {
           symbol.set(Symbol::Flag::Subroutine);
         }
       }
       details->set_interface(interface);
       SetBindNameOn(symbol);
       SetPassNameOn(symbol);
     }
   }
   return symbol;
 }
 
 Symbol &DeclarationVisitor::DeclareObjectEntity(
     const parser::Name &name, Attrs attrs) {
   Symbol &symbol{DeclareEntity<ObjectEntityDetails>(name, attrs)};
   if (auto *details{symbol.detailsIf<ObjectEntityDetails>()}) {
     if (auto *type{GetDeclTypeSpec()}) {
       SetType(name, *type);
     }
     if (!arraySpec().empty()) {
       if (details->IsArray()) {
         if (!context().HasError(symbol)) {
           Say(name,
               "The dimensions of '%s' have already been declared"_err_en_US);
           context().SetError(symbol);
         }
       } else {
         details->set_shape(arraySpec());
       }
     }
     if (!coarraySpec().empty()) {
       if (details->IsCoarray()) {
         if (!context().HasError(symbol)) {
           Say(name,
               "The codimensions of '%s' have already been declared"_err_en_US);
           context().SetError(symbol);
         }
       } else {
         details->set_coshape(coarraySpec());
       }
     }
     SetBindNameOn(symbol);
   }
   ClearArraySpec();
   ClearCoarraySpec();
   charInfo_.length.reset();
   return symbol;
 }
 
 void DeclarationVisitor::Post(const parser::IntegerTypeSpec &x) {
   SetDeclTypeSpec(MakeNumericType(TypeCategory::Integer, x.v));
 }
 void DeclarationVisitor::Post(const parser::IntrinsicTypeSpec::Real &x) {
   SetDeclTypeSpec(MakeNumericType(TypeCategory::Real, x.kind));
 }
 void DeclarationVisitor::Post(const parser::IntrinsicTypeSpec::Complex &x) {
   SetDeclTypeSpec(MakeNumericType(TypeCategory::Complex, x.kind));
 }
 void DeclarationVisitor::Post(const parser::IntrinsicTypeSpec::Logical &x) {
   SetDeclTypeSpec(MakeLogicalType(x.kind));
 }
 void DeclarationVisitor::Post(const parser::IntrinsicTypeSpec::Character &) {
   if (!charInfo_.length) {
     charInfo_.length = ParamValue{1, common::TypeParamAttr::Len};
   }
   if (!charInfo_.kind) {
     charInfo_.kind =
         KindExpr{context().GetDefaultKind(TypeCategory::Character)};
   }
   SetDeclTypeSpec(currScope().MakeCharacterType(
       std::move(*charInfo_.length), std::move(*charInfo_.kind)));
   charInfo_ = {};
 }
 void DeclarationVisitor::Post(const parser::CharSelector::LengthAndKind &x) {
   charInfo_.kind = EvaluateSubscriptIntExpr(x.kind);
   std::optional<std::int64_t> intKind{ToInt64(charInfo_.kind)};
   if (intKind &&
       !evaluate::IsValidKindOfIntrinsicType(
           TypeCategory::Character, *intKind)) { // C715, C719
     Say(currStmtSource().value(),
         "KIND value (%jd) not valid for CHARACTER"_err_en_US, *intKind);
   }
   if (x.length) {
     charInfo_.length = GetParamValue(*x.length, common::TypeParamAttr::Len);
   }
 }
 void DeclarationVisitor::Post(const parser::CharLength &x) {
   if (const auto *length{std::get_if<std::uint64_t>(&x.u)}) {
     charInfo_.length = ParamValue{
         static_cast<ConstantSubscript>(*length), common::TypeParamAttr::Len};
   } else {
     charInfo_.length = GetParamValue(
         std::get<parser::TypeParamValue>(x.u), common::TypeParamAttr::Len);
   }
 }
 void DeclarationVisitor::Post(const parser::LengthSelector &x) {
   if (const auto *param{std::get_if<parser::TypeParamValue>(&x.u)}) {
     charInfo_.length = GetParamValue(*param, common::TypeParamAttr::Len);
   }
 }
 
 bool DeclarationVisitor::Pre(const parser::KindParam &x) {
   if (const auto *kind{std::get_if<
           parser::Scalar<parser::Integer<parser::Constant<parser::Name>>>>(
           &x.u)}) {
     const parser::Name &name{kind->thing.thing.thing};
     if (!FindSymbol(name)) {
       Say(name, "Parameter '%s' not found"_err_en_US);
     }
   }
   return false;
 }
 
 bool DeclarationVisitor::Pre(const parser::DeclarationTypeSpec::Type &) {
   CHECK(GetDeclTypeSpecCategory() == DeclTypeSpec::Category::TypeDerived);
   return true;
 }
 
 void DeclarationVisitor::Post(const parser::DeclarationTypeSpec::Type &type) {
   const parser::Name &derivedName{std::get<parser::Name>(type.derived.t)};
   if (const Symbol * derivedSymbol{derivedName.symbol}) {
     CheckForAbstractType(*derivedSymbol); // C706
   }
 }
 
 bool DeclarationVisitor::Pre(const parser::DeclarationTypeSpec::Class &) {
   SetDeclTypeSpecCategory(DeclTypeSpec::Category::ClassDerived);
   return true;
 }
 
 void DeclarationVisitor::Post(
     const parser::DeclarationTypeSpec::Class &parsedClass) {
   const auto &typeName{std::get<parser::Name>(parsedClass.derived.t)};
   if (auto spec{ResolveDerivedType(typeName)};
       spec && !IsExtensibleType(&*spec)) { // C705
     SayWithDecl(typeName, *typeName.symbol,
         "Non-extensible derived type '%s' may not be used with CLASS"
         " keyword"_err_en_US);
   }
 }
 
 bool DeclarationVisitor::Pre(const parser::DeclarationTypeSpec::Record &) {
   // TODO
   return true;
 }
 
 void DeclarationVisitor::Post(const parser::DerivedTypeSpec &x) {
   const auto &typeName{std::get<parser::Name>(x.t)};
   auto spec{ResolveDerivedType(typeName)};
   if (!spec) {
     return;
   }
   bool seenAnyName{false};
   for (const auto &typeParamSpec :
       std::get<std::list<parser::TypeParamSpec>>(x.t)) {
     const auto &optKeyword{
         std::get<std::optional<parser::Keyword>>(typeParamSpec.t)};
     std::optional<SourceName> name;
     if (optKeyword) {
       seenAnyName = true;
       name = optKeyword->v.source;
     } else if (seenAnyName) {
       Say(typeName.source, "Type parameter value must have a name"_err_en_US);
       continue;
     }
     const auto &value{std::get<parser::TypeParamValue>(typeParamSpec.t)};
     // The expressions in a derived type specifier whose values define
     // non-defaulted type parameters are evaluated (folded) in the enclosing
     // scope.  The KIND/LEN distinction is resolved later in
     // DerivedTypeSpec::CookParameters().
     ParamValue param{GetParamValue(value, common::TypeParamAttr::Kind)};
     if (!param.isExplicit() || param.GetExplicit()) {
       spec->AddRawParamValue(optKeyword, std::move(param));
     }
   }
 
   // The DerivedTypeSpec *spec is used initially as a search key.
   // If it turns out to have the same name and actual parameter
   // value expressions as another DerivedTypeSpec in the current
   // scope does, then we'll use that extant spec; otherwise, when this
   // spec is distinct from all derived types previously instantiated
   // in the current scope, this spec will be moved into that collection.
   const auto &dtDetails{spec->typeSymbol().get<DerivedTypeDetails>()};
   auto category{GetDeclTypeSpecCategory()};
   if (dtDetails.isForwardReferenced()) {
     DeclTypeSpec &type{currScope().MakeDerivedType(category, std::move(*spec))};
     SetDeclTypeSpec(type);
     return;
   }
   // Normalize parameters to produce a better search key.
   spec->CookParameters(GetFoldingContext());
   if (!spec->MightBeParameterized()) {
     spec->EvaluateParameters(GetFoldingContext());
   }
   if (const DeclTypeSpec *
       extant{currScope().FindInstantiatedDerivedType(*spec, category)}) {
     // This derived type and parameter expressions (if any) are already present
     // in this scope.
     SetDeclTypeSpec(*extant);
   } else {
     DeclTypeSpec &type{currScope().MakeDerivedType(category, std::move(*spec))};
     DerivedTypeSpec &derived{type.derivedTypeSpec()};
     if (derived.MightBeParameterized() &&
         currScope().IsParameterizedDerivedType()) {
       // Defer instantiation; use the derived type's definition's scope.
       derived.set_scope(DEREF(spec->typeSymbol().scope()));
     } else {
       auto restorer{
           GetFoldingContext().messages().SetLocation(currStmtSource().value())};
       derived.Instantiate(currScope(), context());
     }
     SetDeclTypeSpec(type);
   }
   // Capture the DerivedTypeSpec in the parse tree for use in building
   // structure constructor expressions.
   x.derivedTypeSpec = &GetDeclTypeSpec()->derivedTypeSpec();
 }
 
 // The descendents of DerivedTypeDef in the parse tree are visited directly
 // in this Pre() routine so that recursive use of the derived type can be
 // supported in the components.
 bool DeclarationVisitor::Pre(const parser::DerivedTypeDef &x) {
   auto &stmt{std::get<parser::Statement<parser::DerivedTypeStmt>>(x.t)};
   Walk(stmt);
   Walk(std::get<std::list<parser::Statement<parser::TypeParamDefStmt>>>(x.t));
   auto &scope{currScope()};
   CHECK(scope.symbol());
   CHECK(scope.symbol()->scope() == &scope);
   auto &details{scope.symbol()->get<DerivedTypeDetails>()};
   std::set<SourceName> paramNames;
   for (auto &paramName : std::get<std::list<parser::Name>>(stmt.statement.t)) {
     details.add_paramName(paramName.source);
     auto *symbol{FindInScope(scope, paramName)};
     if (!symbol) {
       Say(paramName,
           "No definition found for type parameter '%s'"_err_en_US); // C742
       // No symbol for a type param.  Create one and mark it as containing an
       // error to improve subsequent semantic processing
       BeginAttrs();
       Symbol *typeParam{MakeTypeSymbol(
           paramName, TypeParamDetails{common::TypeParamAttr::Len})};
       typeParam->set(Symbol::Flag::Error);
       EndAttrs();
     } else if (!symbol->has<TypeParamDetails>()) {
       Say2(paramName, "'%s' is not defined as a type parameter"_err_en_US,
           *symbol, "Definition of '%s'"_en_US); // C741
     }
     if (!paramNames.insert(paramName.source).second) {
       Say(paramName,
           "Duplicate type parameter name: '%s'"_err_en_US); // C731
     }
   }
   for (const auto &[name, symbol] : currScope()) {
     if (symbol->has<TypeParamDetails>() && !paramNames.count(name)) {
       SayDerivedType(name,
           "'%s' is not a type parameter of this derived type"_err_en_US,
           currScope()); // C741
     }
   }
   Walk(std::get<std::list<parser::Statement<parser::PrivateOrSequence>>>(x.t));
   const auto &componentDefs{
       std::get<std::list<parser::Statement<parser::ComponentDefStmt>>>(x.t)};
   Walk(componentDefs);
   if (derivedTypeInfo_.sequence) {
     details.set_sequence(true);
     if (componentDefs.empty()) { // C740
       Say(stmt.source,
           "A sequence type must have at least one component"_err_en_US);
     }
     if (!details.paramNames().empty()) { // C740
       Say(stmt.source,
           "A sequence type may not have type parameters"_err_en_US);
     }
     if (derivedTypeInfo_.extends) { // C735
       Say(stmt.source,
           "A sequence type may not have the EXTENDS attribute"_err_en_US);
     } else {
       for (const auto &componentName : details.componentNames()) {
         const Symbol *componentSymbol{scope.FindComponent(componentName)};
         if (componentSymbol && componentSymbol->has<ObjectEntityDetails>()) {
           const auto &componentDetails{
               componentSymbol->get<ObjectEntityDetails>()};
           const DeclTypeSpec *componentType{componentDetails.type()};
           if (componentType && // C740
               !componentType->AsIntrinsic() &&
               !componentType->IsSequenceType()) {
             Say(componentSymbol->name(),
                 "A sequence type data component must either be of an"
                 " intrinsic type or a derived sequence type"_err_en_US);
           }
         }
       }
     }
   }
   Walk(std::get<std::optional<parser::TypeBoundProcedurePart>>(x.t));
   Walk(std::get<parser::Statement<parser::EndTypeStmt>>(x.t));
   derivedTypeInfo_ = {};
   PopScope();
   return false;
 }
 bool DeclarationVisitor::Pre(const parser::DerivedTypeStmt &) {
   return BeginAttrs();
 }
 void DeclarationVisitor::Post(const parser::DerivedTypeStmt &x) {
   auto &name{std::get<parser::Name>(x.t)};
   // Resolve the EXTENDS() clause before creating the derived
   // type's symbol to foil attempts to recursively extend a type.
   auto *extendsName{derivedTypeInfo_.extends};
   std::optional<DerivedTypeSpec> extendsType{
       ResolveExtendsType(name, extendsName)};
   auto &symbol{MakeSymbol(name, GetAttrs(), DerivedTypeDetails{})};
   symbol.ReplaceName(name.source);
   derivedTypeInfo_.type = &symbol;
   PushScope(Scope::Kind::DerivedType, &symbol);
   if (extendsType) {
     // Declare the "parent component"; private if the type is.
     // Any symbol stored in the EXTENDS() clause is temporarily
     // hidden so that a new symbol can be created for the parent
     // component without producing spurious errors about already
     // existing.
     const Symbol &extendsSymbol{extendsType->typeSymbol()};
     auto restorer{common::ScopedSet(extendsName->symbol, nullptr)};
     if (OkToAddComponent(*extendsName, &extendsSymbol)) {
       auto &comp{DeclareEntity<ObjectEntityDetails>(*extendsName, Attrs{})};
       comp.attrs().set(
           Attr::PRIVATE, extendsSymbol.attrs().test(Attr::PRIVATE));
       comp.set(Symbol::Flag::ParentComp);
       DeclTypeSpec &type{currScope().MakeDerivedType(
           DeclTypeSpec::TypeDerived, std::move(*extendsType))};
       type.derivedTypeSpec().set_scope(*extendsSymbol.scope());
       comp.SetType(type);
       DerivedTypeDetails &details{symbol.get<DerivedTypeDetails>()};
       details.add_component(comp);
     }
   }
   EndAttrs();
 }
 
 void DeclarationVisitor::Post(const parser::TypeParamDefStmt &x) {
   auto *type{GetDeclTypeSpec()};
   auto attr{std::get<common::TypeParamAttr>(x.t)};
   for (auto &decl : std::get<std::list<parser::TypeParamDecl>>(x.t)) {
     auto &name{std::get<parser::Name>(decl.t)};
     if (Symbol * symbol{MakeTypeSymbol(name, TypeParamDetails{attr})}) {
       SetType(name, *type);
       if (auto &init{
               std::get<std::optional<parser::ScalarIntConstantExpr>>(decl.t)}) {
         if (auto maybeExpr{EvaluateConvertedExpr(
                 *symbol, *init, init->thing.thing.thing.value().source)}) {
           auto *intExpr{std::get_if<SomeIntExpr>(&maybeExpr->u)};
           CHECK(intExpr);
           symbol->get<TypeParamDetails>().set_init(std::move(*intExpr));
         }
       }
     }
   }
   EndDecl();
 }
 bool DeclarationVisitor::Pre(const parser::TypeAttrSpec::Extends &x) {
   if (derivedTypeInfo_.extends) {
     Say(currStmtSource().value(),
         "Attribute 'EXTENDS' cannot be used more than once"_err_en_US);
   } else {
     derivedTypeInfo_.extends = &x.v;
   }
   return false;
 }
 
 bool DeclarationVisitor::Pre(const parser::PrivateStmt &) {
   if (!currScope().parent().IsModule()) {
     Say("PRIVATE is only allowed in a derived type that is"
         " in a module"_err_en_US); // C766
   } else if (derivedTypeInfo_.sawContains) {
     derivedTypeInfo_.privateBindings = true;
   } else if (!derivedTypeInfo_.privateComps) {
     derivedTypeInfo_.privateComps = true;
   } else {
     Say("PRIVATE may not appear more than once in"
         " derived type components"_en_US); // C738
   }
   return false;
 }
 bool DeclarationVisitor::Pre(const parser::SequenceStmt &) {
   if (derivedTypeInfo_.sequence) {
     Say("SEQUENCE may not appear more than once in"
         " derived type components"_en_US); // C738
   }
   derivedTypeInfo_.sequence = true;
   return false;
 }
 void DeclarationVisitor::Post(const parser::ComponentDecl &x) {
   const auto &name{std::get<parser::Name>(x.t)};
   auto attrs{GetAttrs()};
   if (derivedTypeInfo_.privateComps &&
       !attrs.HasAny({Attr::PUBLIC, Attr::PRIVATE})) {
     attrs.set(Attr::PRIVATE);
   }
   if (const auto *declType{GetDeclTypeSpec()}) {
     if (const auto *derived{declType->AsDerived()}) {
       if (!attrs.HasAny({Attr::POINTER, Attr::ALLOCATABLE})) {
         if (derivedTypeInfo_.type == &derived->typeSymbol()) { // C744
           Say("Recursive use of the derived type requires "
               "POINTER or ALLOCATABLE"_err_en_US);
         }
       }
       if (!coarraySpec().empty()) { // C747
         if (IsTeamType(derived)) {
           Say("A coarray component may not be of type TEAM_TYPE from "
               "ISO_FORTRAN_ENV"_err_en_US);
         } else {
           if (IsIsoCType(derived)) {
             Say("A coarray component may not be of type C_PTR or C_FUNPTR from "
                 "ISO_C_BINDING"_err_en_US);
           }
         }
       }
       if (auto it{FindCoarrayUltimateComponent(*derived)}) { // C748
         std::string ultimateName{it.BuildResultDesignatorName()};
         // Strip off the leading "%"
         if (ultimateName.length() > 1) {
           ultimateName.erase(0, 1);
           if (attrs.HasAny({Attr::POINTER, Attr::ALLOCATABLE})) {
             evaluate::AttachDeclaration(
                 Say(name.source,
                     "A component with a POINTER or ALLOCATABLE attribute may "
                     "not "
                     "be of a type with a coarray ultimate component (named "
                     "'%s')"_err_en_US,
                     ultimateName),
                 derived->typeSymbol());
           }
           if (!arraySpec().empty() || !coarraySpec().empty()) {
             evaluate::AttachDeclaration(
                 Say(name.source,
                     "An array or coarray component may not be of a type with a "
                     "coarray ultimate component (named '%s')"_err_en_US,
                     ultimateName),
                 derived->typeSymbol());
           }
         }
       }
     }
   }
   if (OkToAddComponent(name)) {
     auto &symbol{DeclareObjectEntity(name, attrs)};
     if (symbol.has<ObjectEntityDetails>()) {
       if (auto &init{std::get<std::optional<parser::Initialization>>(x.t)}) {
         Initialization(name, *init, true);
       }
     }
     currScope().symbol()->get<DerivedTypeDetails>().add_component(symbol);
   }
   ClearArraySpec();
   ClearCoarraySpec();
 }
 bool DeclarationVisitor::Pre(const parser::ProcedureDeclarationStmt &) {
   CHECK(!interfaceName_);
   return BeginDecl();
 }
 void DeclarationVisitor::Post(const parser::ProcedureDeclarationStmt &) {
   interfaceName_ = nullptr;
   EndDecl();
 }
 bool DeclarationVisitor::Pre(const parser::DataComponentDefStmt &x) {
   // Overrides parse tree traversal so as to handle attributes first,
   // so POINTER & ALLOCATABLE enable forward references to derived types.
   Walk(std::get<std::list<parser::ComponentAttrSpec>>(x.t));
   set_allowForwardReferenceToDerivedType(
       GetAttrs().HasAny({Attr::POINTER, Attr::ALLOCATABLE}));
   Walk(std::get<parser::DeclarationTypeSpec>(x.t));
   set_allowForwardReferenceToDerivedType(false);
   Walk(std::get<std::list<parser::ComponentDecl>>(x.t));
   return false;
 }
 bool DeclarationVisitor::Pre(const parser::ProcComponentDefStmt &) {
   CHECK(!interfaceName_);
   return true;
 }
 void DeclarationVisitor::Post(const parser::ProcComponentDefStmt &) {
   interfaceName_ = nullptr;
 }
 bool DeclarationVisitor::Pre(const parser::ProcPointerInit &x) {
   if (auto *name{std::get_if<parser::Name>(&x.u)}) {
     return !NameIsKnownOrIntrinsic(*name);
   }
   return true;
 }
 void DeclarationVisitor::Post(const parser::ProcInterface &x) {
   if (auto *name{std::get_if<parser::Name>(&x.u)}) {
     interfaceName_ = name;
     NoteInterfaceName(*name);
   }
 }
 
 void DeclarationVisitor::Post(const parser::ProcDecl &x) {
   const auto &name{std::get<parser::Name>(x.t)};
   ProcInterface interface;
   if (interfaceName_) {
     interface.set_symbol(*interfaceName_->symbol);
   } else if (auto *type{GetDeclTypeSpec()}) {
     interface.set_type(*type);
   }
   auto attrs{HandleSaveName(name.source, GetAttrs())};
   DerivedTypeDetails *dtDetails{nullptr};
   if (Symbol * symbol{currScope().symbol()}) {
     dtDetails = symbol->detailsIf<DerivedTypeDetails>();
   }
   if (!dtDetails) {
     attrs.set(Attr::EXTERNAL);
   }
   Symbol &symbol{DeclareProcEntity(name, attrs, interface)};
   symbol.ReplaceName(name.source);
   if (dtDetails) {
     dtDetails->add_component(symbol);
   }
 }
 
 bool DeclarationVisitor::Pre(const parser::TypeBoundProcedurePart &) {
   derivedTypeInfo_.sawContains = true;
   return true;
 }
 
 // Resolve binding names from type-bound generics, saved in genericBindings_.
 void DeclarationVisitor::Post(const parser::TypeBoundProcedurePart &) {
   // track specifics seen for the current generic to detect duplicates:
   const Symbol *currGeneric{nullptr};
   std::set<SourceName> specifics;
   for (const auto &[generic, bindingName] : genericBindings_) {
     if (generic != currGeneric) {
       currGeneric = generic;
       specifics.clear();
     }
     auto [it, inserted]{specifics.insert(bindingName->source)};
     if (!inserted) {
       Say(*bindingName, // C773
           "Binding name '%s' was already specified for generic '%s'"_err_en_US,
           bindingName->source, generic->name())
           .Attach(*it, "Previous specification of '%s'"_en_US, *it);
       continue;
     }
     auto *symbol{FindInTypeOrParents(*bindingName)};
     if (!symbol) {
       Say(*bindingName, // C772
           "Binding name '%s' not found in this derived type"_err_en_US);
     } else if (!symbol->has<ProcBindingDetails>()) {
       SayWithDecl(*bindingName, *symbol, // C772
           "'%s' is not the name of a specific binding of this type"_err_en_US);
     } else {
       generic->get<GenericDetails>().AddSpecificProc(
           *symbol, bindingName->source);
     }
   }
   genericBindings_.clear();
 }
 
 void DeclarationVisitor::Post(const parser::ContainsStmt &) {
   if (derivedTypeInfo_.sequence) {
     Say("A sequence type may not have a CONTAINS statement"_err_en_US); // C740
   }
 }
 
 void DeclarationVisitor::Post(
     const parser::TypeBoundProcedureStmt::WithoutInterface &x) {
   if (GetAttrs().test(Attr::DEFERRED)) { // C783
     Say("DEFERRED is only allowed when an interface-name is provided"_err_en_US);
   }
   for (auto &declaration : x.declarations) {
     auto &bindingName{std::get<parser::Name>(declaration.t)};
     auto &optName{std::get<std::optional<parser::Name>>(declaration.t)};
     const parser::Name &procedureName{optName ? *optName : bindingName};
     Symbol *procedure{FindSymbol(procedureName)};
     if (!procedure) {
       procedure = NoteInterfaceName(procedureName);
     }
     if (auto *s{MakeTypeSymbol(bindingName, ProcBindingDetails{*procedure})}) {
       SetPassNameOn(*s);
       if (GetAttrs().test(Attr::DEFERRED)) {
         context().SetError(*s);
       }
     }
   }
 }
 
 void DeclarationVisitor::CheckBindings(
     const parser::TypeBoundProcedureStmt::WithoutInterface &tbps) {
   CHECK(currScope().IsDerivedType());
   for (auto &declaration : tbps.declarations) {
     auto &bindingName{std::get<parser::Name>(declaration.t)};
     if (Symbol * binding{FindInScope(currScope(), bindingName)}) {
       if (auto *details{binding->detailsIf<ProcBindingDetails>()}) {
         const Symbol *procedure{FindSubprogram(details->symbol())};
         if (!CanBeTypeBoundProc(procedure)) {
           if (details->symbol().name() != binding->name()) {
             Say(binding->name(),
                 "The binding of '%s' ('%s') must be either an accessible "
                 "module procedure or an external procedure with "
                 "an explicit interface"_err_en_US,
                 binding->name(), details->symbol().name());
           } else {
             Say(binding->name(),
                 "'%s' must be either an accessible module procedure "
                 "or an external procedure with an explicit interface"_err_en_US,
                 binding->name());
           }
           context().SetError(*binding);
         }
       }
     }
   }
 }
 
 void DeclarationVisitor::Post(
     const parser::TypeBoundProcedureStmt::WithInterface &x) {
   if (!GetAttrs().test(Attr::DEFERRED)) { // C783
     Say("DEFERRED is required when an interface-name is provided"_err_en_US);
   }
   if (Symbol * interface{NoteInterfaceName(x.interfaceName)}) {
     for (auto &bindingName : x.bindingNames) {
       if (auto *s{
               MakeTypeSymbol(bindingName, ProcBindingDetails{*interface})}) {
         SetPassNameOn(*s);
         if (!GetAttrs().test(Attr::DEFERRED)) {
           context().SetError(*s);
         }
       }
     }
   }
 }
 
 void DeclarationVisitor::Post(const parser::FinalProcedureStmt &x) {
   for (auto &name : x.v) {
     MakeTypeSymbol(name, FinalProcDetails{});
   }
 }
 
 bool DeclarationVisitor::Pre(const parser::TypeBoundGenericStmt &x) {
   const auto &accessSpec{std::get<std::optional<parser::AccessSpec>>(x.t)};
   const auto &genericSpec{std::get<Indirection<parser::GenericSpec>>(x.t)};
   const auto &bindingNames{std::get<std::list<parser::Name>>(x.t)};
   auto info{GenericSpecInfo{genericSpec.value()}};
   SourceName symbolName{info.symbolName()};
   bool isPrivate{accessSpec ? accessSpec->v == parser::AccessSpec::Kind::Private
                             : derivedTypeInfo_.privateBindings};
   auto *genericSymbol{info.FindInScope(context(), currScope())};
   if (genericSymbol) {
     if (!genericSymbol->has<GenericDetails>()) {
       genericSymbol = nullptr; // MakeTypeSymbol will report the error below
     }
   } else {
     // look in parent types:
     Symbol *inheritedSymbol{nullptr};
     for (const auto &name : info.GetAllNames(context())) {
       inheritedSymbol = currScope().FindComponent(SourceName{name});
       if (inheritedSymbol) {
         break;
       }
     }
     if (inheritedSymbol && inheritedSymbol->has<GenericDetails>()) {
       CheckAccessibility(symbolName, isPrivate, *inheritedSymbol); // C771
     }
   }
   if (genericSymbol) {
     CheckAccessibility(symbolName, isPrivate, *genericSymbol); // C771
   } else {
     genericSymbol = MakeTypeSymbol(symbolName, GenericDetails{});
     if (!genericSymbol) {
       return false;
     }
     if (isPrivate) {
       genericSymbol->attrs().set(Attr::PRIVATE);
     }
   }
   for (const parser::Name &bindingName : bindingNames) {
     genericBindings_.emplace(genericSymbol, &bindingName);
   }
   info.Resolve(genericSymbol);
   return false;
 }
 
 bool DeclarationVisitor::Pre(const parser::AllocateStmt &) {
   BeginDeclTypeSpec();
   return true;
 }
 void DeclarationVisitor::Post(const parser::AllocateStmt &) {
   EndDeclTypeSpec();
 }
 
 bool DeclarationVisitor::Pre(const parser::StructureConstructor &x) {
   auto &parsedType{std::get<parser::DerivedTypeSpec>(x.t)};
   const DeclTypeSpec *type{ProcessTypeSpec(parsedType)};
   if (!type) {
     return false;
   }
   const DerivedTypeSpec *spec{type->AsDerived()};
   const Scope *typeScope{spec ? spec->scope() : nullptr};
   if (!typeScope) {
     return false;
   }
 
   // N.B C7102 is implicitly enforced by having inaccessible types not
   // being found in resolution.
   // More constraints are enforced in expression.cpp so that they
   // can apply to structure constructors that have been converted
   // from misparsed function references.
   for (const auto &component :
       std::get<std::list<parser::ComponentSpec>>(x.t)) {
     // Visit the component spec expression, but not the keyword, since
     // we need to resolve its symbol in the scope of the derived type.
     Walk(std::get<parser::ComponentDataSource>(component.t));
     if (const auto &kw{std::get<std::optional<parser::Keyword>>(component.t)}) {
       FindInTypeOrParents(*typeScope, kw->v);
     }
   }
   return false;
 }
 
 bool DeclarationVisitor::Pre(const parser::BasedPointerStmt &x) {
   for (const parser::BasedPointer &bp : x.v) {
     const parser::ObjectName &pointerName{std::get<0>(bp.t)};
     const parser::ObjectName &pointeeName{std::get<1>(bp.t)};
     auto *pointer{FindSymbol(pointerName)};
     if (!pointer) {
       pointer = &MakeSymbol(pointerName, ObjectEntityDetails{});
     } else if (!ConvertToObjectEntity(*pointer) || IsNamedConstant(*pointer)) {
       SayWithDecl(pointerName, *pointer, "'%s' is not a variable"_err_en_US);
     } else if (pointer->Rank() > 0) {
       SayWithDecl(pointerName, *pointer,
           "Cray pointer '%s' must be a scalar"_err_en_US);
     } else if (pointer->test(Symbol::Flag::CrayPointee)) {
       Say(pointerName,
           "'%s' cannot be a Cray pointer as it is already a Cray pointee"_err_en_US);
     }
     pointer->set(Symbol::Flag::CrayPointer);
     const DeclTypeSpec &pointerType{MakeNumericType(TypeCategory::Integer,
         context().defaultKinds().subscriptIntegerKind())};
     const auto *type{pointer->GetType()};
     if (!type) {
       pointer->SetType(pointerType);
     } else if (*type != pointerType) {
       Say(pointerName.source, "Cray pointer '%s' must have type %s"_err_en_US,
           pointerName.source, pointerType.AsFortran());
     }
     if (ResolveName(pointeeName)) {
       Symbol &pointee{*pointeeName.symbol};
       if (pointee.has<UseDetails>()) {
         Say(pointeeName,
             "'%s' cannot be a Cray pointee as it is use-associated"_err_en_US);
         continue;
       } else if (!ConvertToObjectEntity(pointee) || IsNamedConstant(pointee)) {
         Say(pointeeName, "'%s' is not a variable"_err_en_US);
         continue;
       } else if (pointee.test(Symbol::Flag::CrayPointer)) {
         Say(pointeeName,
             "'%s' cannot be a Cray pointee as it is already a Cray pointer"_err_en_US);
       } else if (pointee.test(Symbol::Flag::CrayPointee)) {
         Say(pointeeName,
             "'%s' was already declared as a Cray pointee"_err_en_US);
       } else {
         pointee.set(Symbol::Flag::CrayPointee);
       }
       if (const auto *pointeeType{pointee.GetType()}) {
         if (const auto *derived{pointeeType->AsDerived()}) {
           if (!derived->typeSymbol().get<DerivedTypeDetails>().sequence()) {
             Say(pointeeName,
                 "Type of Cray pointee '%s' is a non-sequence derived type"_err_en_US);
           }
         }
       }
       // process the pointee array-spec, if present
       BeginArraySpec();
       Walk(std::get<std::optional<parser::ArraySpec>>(bp.t));
       const auto &spec{arraySpec()};
       if (!spec.empty()) {
         auto &details{pointee.get<ObjectEntityDetails>()};
         if (details.shape().empty()) {
           details.set_shape(spec);
         } else {
           SayWithDecl(pointeeName, pointee,
               "Array spec was already declared for '%s'"_err_en_US);
         }
       }
       ClearArraySpec();
       currScope().add_crayPointer(pointeeName.source, *pointer);
     }
   }
   return false;
 }
 
 bool DeclarationVisitor::Pre(const parser::NamelistStmt::Group &x) {
   if (!CheckNotInBlock("NAMELIST")) { // C1107
     return false;
   }
 
   NamelistDetails details;
   for (const auto &name : std::get<std::list<parser::Name>>(x.t)) {
     auto *symbol{FindSymbol(name)};
     if (!symbol) {
       symbol = &MakeSymbol(name, ObjectEntityDetails{});
       ApplyImplicitRules(*symbol);
     } else if (!ConvertToObjectEntity(*symbol)) {
       SayWithDecl(name, *symbol, "'%s' is not a variable"_err_en_US);
     }
     details.add_object(*symbol);
   }
 
   const auto &groupName{std::get<parser::Name>(x.t)};
   auto *groupSymbol{FindInScope(currScope(), groupName)};
   if (!groupSymbol || !groupSymbol->has<NamelistDetails>()) {
     groupSymbol = &MakeSymbol(groupName, std::move(details));
     groupSymbol->ReplaceName(groupName.source);
   }
   groupSymbol->get<NamelistDetails>().add_objects(details.objects());
   return false;
 }
 
 bool DeclarationVisitor::Pre(const parser::IoControlSpec &x) {
   if (const auto *name{std::get_if<parser::Name>(&x.u)}) {
     auto *symbol{FindSymbol(*name)};
     if (!symbol) {
       Say(*name, "Namelist group '%s' not found"_err_en_US);
     } else if (!symbol->GetUltimate().has<NamelistDetails>()) {
       SayWithDecl(
           *name, *symbol, "'%s' is not the name of a namelist group"_err_en_US);
     }
   }
   return true;
 }
 
 bool DeclarationVisitor::Pre(const parser::CommonStmt::Block &x) {
   CheckNotInBlock("COMMON"); // C1107
   const auto &optName{std::get<std::optional<parser::Name>>(x.t)};
   parser::Name blankCommon;
   blankCommon.source =
       SourceName{currStmtSource().value().begin(), std::size_t{0}};
   CHECK(!commonBlockInfo_.curr);
   commonBlockInfo_.curr =
       &MakeCommonBlockSymbol(optName ? *optName : blankCommon);
   return true;
 }
 
 void DeclarationVisitor::Post(const parser::CommonStmt::Block &) {
   commonBlockInfo_.curr = nullptr;
 }
 
 bool DeclarationVisitor::Pre(const parser::CommonBlockObject &) {
   BeginArraySpec();
   return true;
 }
 
 void DeclarationVisitor::Post(const parser::CommonBlockObject &x) {
   CHECK(commonBlockInfo_.curr);
   const auto &name{std::get<parser::Name>(x.t)};
   auto &symbol{DeclareObjectEntity(name, Attrs{})};
   ClearArraySpec();
   ClearCoarraySpec();
   auto *details{symbol.detailsIf<ObjectEntityDetails>()};
   if (!details) {
     return; // error was reported
   }
   commonBlockInfo_.curr->get<CommonBlockDetails>().add_object(symbol);
   auto pair{commonBlockInfo_.names.insert(name.source)};
   if (!pair.second) {
     const SourceName &prev{*pair.first};
     Say2(name.source, "'%s' is already in a COMMON block"_err_en_US, prev,
         "Previous occurrence of '%s' in a COMMON block"_en_US);
     return;
   }
   details->set_commonBlock(*commonBlockInfo_.curr);
 }
 
 bool DeclarationVisitor::Pre(const parser::EquivalenceStmt &x) {
   // save equivalence sets to be processed after specification part
   CheckNotInBlock("EQUIVALENCE"); // C1107
   for (const std::list<parser::EquivalenceObject> &set : x.v) {
     equivalenceSets_.push_back(&set);
   }
   return false; // don't implicitly declare names yet
 }
 
 void DeclarationVisitor::CheckEquivalenceSets() {
   EquivalenceSets equivSets{context()};
   for (const auto *set : equivalenceSets_) {
     const auto &source{set->front().v.value().source};
     if (set->size() <= 1) { // R871
       Say(source, "Equivalence set must have more than one object"_err_en_US);
     }
     for (const parser::EquivalenceObject &object : *set) {
       const auto &designator{object.v.value()};
       // The designator was not resolved when it was encountered so do it now.
       // AnalyzeExpr causes array sections to be changed to substrings as needed
       Walk(designator);
       if (AnalyzeExpr(context(), designator)) {
         equivSets.AddToSet(designator);
       }
     }
     equivSets.FinishSet(source);
   }
   for (auto &set : equivSets.sets()) {
     if (!set.empty()) {
       currScope().add_equivalenceSet(std::move(set));
     }
   }
   equivalenceSets_.clear();
 }
 
 bool DeclarationVisitor::Pre(const parser::SaveStmt &x) {
   if (x.v.empty()) {
     saveInfo_.saveAll = currStmtSource();
     currScope().set_hasSAVE();
   } else {
     for (const parser::SavedEntity &y : x.v) {
       auto kind{std::get<parser::SavedEntity::Kind>(y.t)};
       const auto &name{std::get<parser::Name>(y.t)};
       if (kind == parser::SavedEntity::Kind::Common) {
         MakeCommonBlockSymbol(name);
         AddSaveName(saveInfo_.commons, name.source);
       } else {
         HandleAttributeStmt(Attr::SAVE, name);
       }
     }
   }
   return false;
 }
 
 void DeclarationVisitor::CheckSaveStmts() {
   for (const SourceName &name : saveInfo_.entities) {
     auto *symbol{FindInScope(currScope(), name)};
     if (!symbol) {
       // error was reported
     } else if (saveInfo_.saveAll) {
       // C889 - note that pgi, ifort, xlf do not enforce this constraint
       Say2(name,
           "Explicit SAVE of '%s' is redundant due to global SAVE statement"_err_en_US,
           *saveInfo_.saveAll, "Global SAVE statement"_en_US);
     } else if (auto msg{CheckSaveAttr(*symbol)}) {
       Say(name, std::move(*msg));
       context().SetError(*symbol);
     } else {
       SetSaveAttr(*symbol);
     }
   }
   for (const SourceName &name : saveInfo_.commons) {
     if (auto *symbol{currScope().FindCommonBlock(name)}) {
       auto &objects{symbol->get<CommonBlockDetails>().objects()};
       if (objects.empty()) {
         if (currScope().kind() != Scope::Kind::Block) {
           Say(name,
               "'%s' appears as a COMMON block in a SAVE statement but not in"
               " a COMMON statement"_err_en_US);
         } else { // C1108
           Say(name,
               "SAVE statement in BLOCK construct may not contain a"
               " common block name '%s'"_err_en_US);
         }
       } else {
         for (auto &object : symbol->get<CommonBlockDetails>().objects()) {
           SetSaveAttr(*object);
         }
       }
     }
   }
   if (saveInfo_.saveAll) {
     // Apply SAVE attribute to applicable symbols
     for (auto pair : currScope()) {
       auto &symbol{*pair.second};
       if (!CheckSaveAttr(symbol)) {
         SetSaveAttr(symbol);
       }
     }
   }
   saveInfo_ = {};
 }
 
 // If SAVE attribute can't be set on symbol, return error message.
 std::optional<MessageFixedText> DeclarationVisitor::CheckSaveAttr(
     const Symbol &symbol) {
   if (IsDummy(symbol)) {
     return "SAVE attribute may not be applied to dummy argument '%s'"_err_en_US;
   } else if (symbol.IsFuncResult()) {
     return "SAVE attribute may not be applied to function result '%s'"_err_en_US;
   } else if (symbol.has<ProcEntityDetails>() &&
       !symbol.attrs().test(Attr::POINTER)) {
     return "Procedure '%s' with SAVE attribute must also have POINTER attribute"_err_en_US;
   } else if (IsAutomatic(symbol)) {
     return "SAVE attribute may not be applied to automatic data object '%s'"_err_en_US;
   } else {
     return std::nullopt;
   }
 }
 
 // Record SAVEd names in saveInfo_.entities.
 Attrs DeclarationVisitor::HandleSaveName(const SourceName &name, Attrs attrs) {
   if (attrs.test(Attr::SAVE)) {
     AddSaveName(saveInfo_.entities, name);
   }
   return attrs;
 }
 
 // Record a name in a set of those to be saved.
 void DeclarationVisitor::AddSaveName(
     std::set<SourceName> &set, const SourceName &name) {
   auto pair{set.insert(name)};
   if (!pair.second) {
     Say2(name, "SAVE attribute was already specified on '%s'"_err_en_US,
         *pair.first, "Previous specification of SAVE attribute"_en_US);
   }
 }
 
 // Set the SAVE attribute on symbol unless it is implicitly saved anyway.
 void DeclarationVisitor::SetSaveAttr(Symbol &symbol) {
   if (!IsSaved(symbol)) {
     symbol.attrs().set(Attr::SAVE);
   }
 }
 
 // Check types of common block objects, now that they are known.
 void DeclarationVisitor::CheckCommonBlocks() {
   // check for empty common blocks
   for (const auto &pair : currScope().commonBlocks()) {
     const auto &symbol{*pair.second};
     if (symbol.get<CommonBlockDetails>().objects().empty() &&
         symbol.attrs().test(Attr::BIND_C)) {
       Say(symbol.name(),
           "'%s' appears as a COMMON block in a BIND statement but not in"
           " a COMMON statement"_err_en_US);
     }
   }
   // check objects in common blocks
   for (const auto &name : commonBlockInfo_.names) {
     const auto *symbol{currScope().FindSymbol(name)};
     if (!symbol) {
       continue;
     }
     const auto &attrs{symbol->attrs()};
     if (attrs.test(Attr::ALLOCATABLE)) {
       Say(name,
           "ALLOCATABLE object '%s' may not appear in a COMMON block"_err_en_US);
     } else if (attrs.test(Attr::BIND_C)) {
       Say(name,
           "Variable '%s' with BIND attribute may not appear in a COMMON block"_err_en_US);
     } else if (IsDummy(*symbol)) {
       Say(name,
           "Dummy argument '%s' may not appear in a COMMON block"_err_en_US);
     } else if (symbol->IsFuncResult()) {
       Say(name,
           "Function result '%s' may not appear in a COMMON block"_err_en_US);
     } else if (const DeclTypeSpec * type{symbol->GetType()}) {
       if (type->category() == DeclTypeSpec::ClassStar) {
         Say(name,
             "Unlimited polymorphic pointer '%s' may not appear in a COMMON block"_err_en_US);
       } else if (const auto *derived{type->AsDerived()}) {
         auto &typeSymbol{derived->typeSymbol()};
         if (!typeSymbol.attrs().test(Attr::BIND_C) &&
             !typeSymbol.get<DerivedTypeDetails>().sequence()) {
           Say(name,
               "Derived type '%s' in COMMON block must have the BIND or"
               " SEQUENCE attribute"_err_en_US);
         }
         CheckCommonBlockDerivedType(name, typeSymbol);
       }
     }
   }
   commonBlockInfo_ = {};
 }
 
 Symbol &DeclarationVisitor::MakeCommonBlockSymbol(const parser::Name &name) {
   return Resolve(name, currScope().MakeCommonBlock(name.source));
 }
 
 bool DeclarationVisitor::NameIsKnownOrIntrinsic(const parser::Name &name) {
   return FindSymbol(name) || HandleUnrestrictedSpecificIntrinsicFunction(name);
 }
 
 // Check if this derived type can be in a COMMON block.
 void DeclarationVisitor::CheckCommonBlockDerivedType(
     const SourceName &name, const Symbol &typeSymbol) {
   if (const auto *scope{typeSymbol.scope()}) {
     for (const auto &pair : *scope) {
       const Symbol &component{*pair.second};
       if (component.attrs().test(Attr::ALLOCATABLE)) {
         Say2(name,
             "Derived type variable '%s' may not appear in a COMMON block"
             " due to ALLOCATABLE component"_err_en_US,
             component.name(), "Component with ALLOCATABLE attribute"_en_US);
         return;
       }
       if (const auto *details{component.detailsIf<ObjectEntityDetails>()}) {
         if (details->init()) {
           Say2(name,
               "Derived type variable '%s' may not appear in a COMMON block"
               " due to component with default initialization"_err_en_US,
               component.name(), "Component with default initialization"_en_US);
           return;
         }
         if (const auto *type{details->type()}) {
           if (const auto *derived{type->AsDerived()}) {
             CheckCommonBlockDerivedType(name, derived->typeSymbol());
           }
         }
       }
     }
   }
 }
 
 bool DeclarationVisitor::HandleUnrestrictedSpecificIntrinsicFunction(
     const parser::Name &name) {
   if (auto interface{context().intrinsics().IsSpecificIntrinsicFunction(
           name.source.ToString())}) {
     // Unrestricted specific intrinsic function names (e.g., "cos")
     // are acceptable as procedure interfaces.
     Symbol &symbol{
         MakeSymbol(InclusiveScope(), name.source, Attrs{Attr::INTRINSIC})};
     if (interface->IsElemental()) {
       symbol.attrs().set(Attr::ELEMENTAL);
     }
     symbol.set_details(ProcEntityDetails{});
     Resolve(name, symbol);
     return true;
   } else {
     return false;
   }
 }
 
 // Checks for all locality-specs: LOCAL, LOCAL_INIT, and SHARED
 bool DeclarationVisitor::PassesSharedLocalityChecks(
     const parser::Name &name, Symbol &symbol) {
   if (!IsVariableName(symbol)) {
     SayLocalMustBeVariable(name, symbol); // C1124
     return false;
   }
   if (symbol.owner() == currScope()) { // C1125 and C1126
     SayAlreadyDeclared(name, symbol);
     return false;
   }
   return true;
 }
 
 // Checks for locality-specs LOCAL and LOCAL_INIT
 bool DeclarationVisitor::PassesLocalityChecks(
     const parser::Name &name, Symbol &symbol) {
   if (IsAllocatable(symbol)) { // C1128
     SayWithDecl(name, symbol,
         "ALLOCATABLE variable '%s' not allowed in a locality-spec"_err_en_US);
     return false;
   }
   if (IsOptional(symbol)) { // C1128
     SayWithDecl(name, symbol,
         "OPTIONAL argument '%s' not allowed in a locality-spec"_err_en_US);
     return false;
   }
   if (IsIntentIn(symbol)) { // C1128
     SayWithDecl(name, symbol,
         "INTENT IN argument '%s' not allowed in a locality-spec"_err_en_US);
     return false;
   }
   if (IsFinalizable(symbol)) { // C1128
     SayWithDecl(name, symbol,
         "Finalizable variable '%s' not allowed in a locality-spec"_err_en_US);
     return false;
   }
   if (IsCoarray(symbol)) { // C1128
     SayWithDecl(
         name, symbol, "Coarray '%s' not allowed in a locality-spec"_err_en_US);
     return false;
   }
   if (const DeclTypeSpec * type{symbol.GetType()}) {
     if (type->IsPolymorphic() && IsDummy(symbol) &&
         !IsPointer(symbol)) { // C1128
       SayWithDecl(name, symbol,
           "Nonpointer polymorphic argument '%s' not allowed in a "
           "locality-spec"_err_en_US);
       return false;
     }
   }
   if (IsAssumedSizeArray(symbol)) { // C1128
     SayWithDecl(name, symbol,
         "Assumed size array '%s' not allowed in a locality-spec"_err_en_US);
     return false;
   }
   if (std::optional<MessageFixedText> msg{
           WhyNotModifiable(symbol, currScope())}) {
     SayWithReason(name, symbol,
         "'%s' may not appear in a locality-spec because it is not "
         "definable"_err_en_US,
         std::move(*msg));
     return false;
   }
   return PassesSharedLocalityChecks(name, symbol);
 }
 
 Symbol &DeclarationVisitor::FindOrDeclareEnclosingEntity(
     const parser::Name &name) {
   Symbol *prev{FindSymbol(name)};
   if (!prev) {
     // Declare the name as an object in the enclosing scope so that
     // the name can't be repurposed there later as something else.
     prev = &MakeSymbol(InclusiveScope(), name.source, Attrs{});
     ConvertToObjectEntity(*prev);
     ApplyImplicitRules(*prev);
   }
   return *prev;
 }
 
 Symbol *DeclarationVisitor::DeclareLocalEntity(const parser::Name &name) {
   Symbol &prev{FindOrDeclareEnclosingEntity(name)};
   if (!PassesLocalityChecks(name, prev)) {
     return nullptr;
   }
   Symbol &symbol{MakeSymbol(name, HostAssocDetails{prev})};
   name.symbol = &symbol;
   return &symbol;
 }
 
 Symbol *DeclarationVisitor::DeclareStatementEntity(const parser::Name &name,
     const std::optional<parser::IntegerTypeSpec> &type) {
   const DeclTypeSpec *declTypeSpec{nullptr};
   if (auto *prev{FindSymbol(name)}) {
     if (prev->owner() == currScope()) {
       SayAlreadyDeclared(name, *prev);
       return nullptr;
     }
     name.symbol = nullptr;
     declTypeSpec = prev->GetType();
   }
   Symbol &symbol{DeclareEntity<ObjectEntityDetails>(name, {})};
   if (!symbol.has<ObjectEntityDetails>()) {
     return nullptr; // error was reported in DeclareEntity
   }
   if (type) {
     declTypeSpec = ProcessTypeSpec(*type);
   }
   if (declTypeSpec) {
     // Subtlety: Don't let a "*length" specifier (if any is pending) affect the
     // declaration of this implied DO loop control variable.
     auto restorer{
         common::ScopedSet(charInfo_.length, std::optional<ParamValue>{})};
     SetType(name, *declTypeSpec);
   } else {
     ApplyImplicitRules(symbol);
   }
   return Resolve(name, &symbol);
 }
 
 // Set the type of an entity or report an error.
 void DeclarationVisitor::SetType(
     const parser::Name &name, const DeclTypeSpec &type) {
   CHECK(name.symbol);
   auto &symbol{*name.symbol};
   if (charInfo_.length) { // Declaration has "*length" (R723)
     auto length{std::move(*charInfo_.length)};
     charInfo_.length.reset();
     if (type.category() == DeclTypeSpec::Character) {
       auto kind{type.characterTypeSpec().kind()};
       // Recurse with correct type.
       SetType(name,
           currScope().MakeCharacterType(std::move(length), std::move(kind)));
       return;
     } else { // C753
       Say(name,
           "A length specifier cannot be used to declare the non-character entity '%s'"_err_en_US);
     }
   }
   auto *prevType{symbol.GetType()};
   if (!prevType) {
     symbol.SetType(type);
   } else if (symbol.has<UseDetails>()) {
     // error recovery case, redeclaration of use-associated name
   } else if (!symbol.test(Symbol::Flag::Implicit)) {
     SayWithDecl(
         name, symbol, "The type of '%s' has already been declared"_err_en_US);
     context().SetError(symbol);
   } else if (type != *prevType) {
     SayWithDecl(name, symbol,
         "The type of '%s' has already been implicitly declared"_err_en_US);
     context().SetError(symbol);
   } else {
     symbol.set(Symbol::Flag::Implicit, false);
   }
 }
 
 std::optional<DerivedTypeSpec> DeclarationVisitor::ResolveDerivedType(
     const parser::Name &name) {
   Symbol *symbol{FindSymbol(NonDerivedTypeScope(), name)};
   if (!symbol || symbol->has<UnknownDetails>()) {
     if (allowForwardReferenceToDerivedType()) {
       if (!symbol) {
         symbol = &MakeSymbol(InclusiveScope(), name.source, Attrs{});
         Resolve(name, *symbol);
       };
       DerivedTypeDetails details;
       details.set_isForwardReferenced();
       symbol->set_details(std::move(details));
     } else { // C732
       Say(name, "Derived type '%s' not found"_err_en_US);
       return std::nullopt;
     }
   }
   if (CheckUseError(name)) {
     return std::nullopt;
   }
   symbol = &symbol->GetUltimate();
   if (auto *details{symbol->detailsIf<GenericDetails>()}) {
     if (details->derivedType()) {
       symbol = details->derivedType();
     }
   }
   if (symbol->has<DerivedTypeDetails>()) {
     return DerivedTypeSpec{name.source, *symbol};
   } else {
     Say(name, "'%s' is not a derived type"_err_en_US);
     return std::nullopt;
   }
 }
 
 std::optional<DerivedTypeSpec> DeclarationVisitor::ResolveExtendsType(
     const parser::Name &typeName, const parser::Name *extendsName) {
   if (!extendsName) {
     return std::nullopt;
   } else if (typeName.source == extendsName->source) {
     Say(extendsName->source,
         "Derived type '%s' cannot extend itself"_err_en_US);
     return std::nullopt;
   } else {
     return ResolveDerivedType(*extendsName);
   }
 }
 
 Symbol *DeclarationVisitor::NoteInterfaceName(const parser::Name &name) {
   // The symbol is checked later by CheckExplicitInterface() and
   // CheckBindings().  It can be a forward reference.
   if (!NameIsKnownOrIntrinsic(name)) {
     Symbol &symbol{MakeSymbol(InclusiveScope(), name.source, Attrs{})};
     Resolve(name, symbol);
   }
   return name.symbol;
 }
 
 void DeclarationVisitor::CheckExplicitInterface(const parser::Name &name) {
   if (const Symbol * symbol{name.symbol}) {
     if (!symbol->HasExplicitInterface()) {
       Say(name,
           "'%s' must be an abstract interface or a procedure with "
           "an explicit interface"_err_en_US,
           symbol->name());
     }
   }
 }
 
 // Create a symbol for a type parameter, component, or procedure binding in
 // the current derived type scope. Return false on error.
 Symbol *DeclarationVisitor::MakeTypeSymbol(
     const parser::Name &name, Details &&details) {
   return Resolve(name, MakeTypeSymbol(name.source, std::move(details)));
 }
 Symbol *DeclarationVisitor::MakeTypeSymbol(
     const SourceName &name, Details &&details) {
   Scope &derivedType{currScope()};
   CHECK(derivedType.IsDerivedType());
   if (auto *symbol{FindInScope(derivedType, name)}) { // C742
     Say2(name,
         "Type parameter, component, or procedure binding '%s'"
         " already defined in this type"_err_en_US,
         *symbol, "Previous definition of '%s'"_en_US);
     return nullptr;
   } else {
     auto attrs{GetAttrs()};
     // Apply binding-private-stmt if present and this is a procedure binding
     if (derivedTypeInfo_.privateBindings &&
         !attrs.HasAny({Attr::PUBLIC, Attr::PRIVATE}) &&
         std::holds_alternative<ProcBindingDetails>(details)) {
       attrs.set(Attr::PRIVATE);
     }
     Symbol &result{MakeSymbol(name, attrs, std::move(details))};
     if (result.has<TypeParamDetails>()) {
       derivedType.symbol()->get<DerivedTypeDetails>().add_paramDecl(result);
     }
     return &result;
   }
 }
 
 // Return true if it is ok to declare this component in the current scope.
 // Otherwise, emit an error and return false.
 bool DeclarationVisitor::OkToAddComponent(
     const parser::Name &name, const Symbol *extends) {
   for (const Scope *scope{&currScope()}; scope;) {
     CHECK(scope->IsDerivedType());
     if (auto *prev{FindInScope(*scope, name)}) {
       if (!prev->test(Symbol::Flag::Error)) {
         auto msg{""_en_US};
         if (extends) {
           msg = "Type cannot be extended as it has a component named"
                 " '%s'"_err_en_US;
         } else if (prev->test(Symbol::Flag::ParentComp)) {
           msg = "'%s' is a parent type of this type and so cannot be"
                 " a component"_err_en_US;
         } else if (scope != &currScope()) {
           msg = "Component '%s' is already declared in a parent of this"
                 " derived type"_err_en_US;
         } else {
           msg = "Component '%s' is already declared in this"
                 " derived type"_err_en_US;
         }
         Say2(name, std::move(msg), *prev, "Previous declaration of '%s'"_en_US);
       }
       return false;
     }
     if (scope == &currScope() && extends) {
       // The parent component has not yet been added to the scope.
       scope = extends->scope();
     } else {
       scope = scope->GetDerivedTypeParent();
     }
   }
   return true;
 }
 
 ParamValue DeclarationVisitor::GetParamValue(
     const parser::TypeParamValue &x, common::TypeParamAttr attr) {
   return std::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);
           },
       },
       x.u);
 }
 
 // ConstructVisitor implementation
 
 void ConstructVisitor::ResolveIndexName(
     const parser::ConcurrentControl &control) {
   const parser::Name &name{std::get<parser::Name>(control.t)};
   auto *prev{FindSymbol(name)};
   if (prev) {
     if (prev->owner().kind() == Scope::Kind::Forall ||
         prev->owner() == currScope()) {
       SayAlreadyDeclared(name, *prev);
       return;
     }
     name.symbol = nullptr;
   }
   auto &symbol{DeclareObjectEntity(name, {})};
 
   if (symbol.GetType()) {
     // type came from explicit type-spec
   } else if (!prev) {
     ApplyImplicitRules(symbol);
   } else if (!prev->has<ObjectEntityDetails>() && !prev->has<EntityDetails>()) {
     Say2(name, "Index name '%s' conflicts with existing identifier"_err_en_US,
         *prev, "Previous declaration of '%s'"_en_US);
     return;
   } else {
     if (const auto *type{prev->GetType()}) {
       symbol.SetType(*type);
     }
     if (prev->IsObjectArray()) {
       SayWithDecl(name, *prev, "Index variable '%s' is not scalar"_err_en_US);
       return;
     }
   }
   EvaluateExpr(parser::Scalar{parser::Integer{common::Clone(name)}});
 }
 
 // We need to make sure that all of the index-names get declared before the
 // expressions in the loop control are evaluated so that references to the
 // index-names in the expressions are correctly detected.
 bool ConstructVisitor::Pre(const parser::ConcurrentHeader &header) {
   BeginDeclTypeSpec();
   Walk(std::get<std::optional<parser::IntegerTypeSpec>>(header.t));
   const auto &controls{
       std::get<std::list<parser::ConcurrentControl>>(header.t)};
   for (const auto &control : controls) {
     ResolveIndexName(control);
   }
   Walk(controls);
   Walk(std::get<std::optional<parser::ScalarLogicalExpr>>(header.t));
   EndDeclTypeSpec();
   return false;
 }
 
 bool ConstructVisitor::Pre(const parser::LocalitySpec::Local &x) {
   for (auto &name : x.v) {
     if (auto *symbol{DeclareLocalEntity(name)}) {
       symbol->set(Symbol::Flag::LocalityLocal);
     }
   }
   return false;
 }
 
 bool ConstructVisitor::Pre(const parser::LocalitySpec::LocalInit &x) {
   for (auto &name : x.v) {
     if (auto *symbol{DeclareLocalEntity(name)}) {
       symbol->set(Symbol::Flag::LocalityLocalInit);
     }
   }
   return false;
 }
 
 bool ConstructVisitor::Pre(const parser::LocalitySpec::Shared &x) {
   for (const auto &name : x.v) {
     if (!FindSymbol(name)) {
       Say(name, "Variable '%s' with SHARED locality implicitly declared"_en_US);
     }
     Symbol &prev{FindOrDeclareEnclosingEntity(name)};
     if (PassesSharedLocalityChecks(name, prev)) {
       auto &symbol{MakeSymbol(name, HostAssocDetails{prev})};
       symbol.set(Symbol::Flag::LocalityShared);
       name.symbol = &symbol; // override resolution to parent
     }
   }
   return false;
 }
 
 bool ConstructVisitor::Pre(const parser::AcSpec &x) {
   ProcessTypeSpec(x.type);
   PushScope(Scope::Kind::ImpliedDos, nullptr);
   Walk(x.values);
   PopScope();
   return false;
 }
 
 bool ConstructVisitor::Pre(const parser::AcImpliedDo &x) {
   auto &values{std::get<std::list<parser::AcValue>>(x.t)};
   auto &control{std::get<parser::AcImpliedDoControl>(x.t)};
   auto &type{std::get<std::optional<parser::IntegerTypeSpec>>(control.t)};
   auto &bounds{std::get<parser::AcImpliedDoControl::Bounds>(control.t)};
   DeclareStatementEntity(bounds.name.thing.thing, type);
   Walk(bounds);
   Walk(values);
   return false;
 }
 
 bool ConstructVisitor::Pre(const parser::DataImpliedDo &x) {
   auto &objects{std::get<std::list<parser::DataIDoObject>>(x.t)};
   auto &type{std::get<std::optional<parser::IntegerTypeSpec>>(x.t)};
   auto &bounds{std::get<parser::DataImpliedDo::Bounds>(x.t)};
   DeclareStatementEntity(bounds.name.thing.thing, type);
   Walk(bounds);
   Walk(objects);
   return false;
 }
 
 // Sets InDataStmt flag on a variable (or misidentified function) in a DATA
 // statement so that the predicate IsInitialized(base symbol) will be true
 // during semantic analysis before the symbol's initializer is constructed.
 bool ConstructVisitor::Pre(const parser::DataIDoObject &x) {
   std::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{
                  [&](const Indirection<parser::Variable> &y) {
                    Walk(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)}) {
     if (const auto *name{std::get_if<parser::Name>(&elem->base.u)}) {
       if (const Symbol * symbol{FindSymbol(*name)}) {
         if (const Symbol * ultimate{GetAssociationRoot(*symbol)}) {
           if (ultimate->has<DerivedTypeDetails>()) {
             mutableData.u = elem->ConvertToStructureConstructor(
                 DerivedTypeSpec{name->source, *ultimate});
           }
         }
       }
     }
   }
   return true;
 }
 
 bool ConstructVisitor::Pre(const parser::DoConstruct &x) {
   if (x.IsDoConcurrent()) {
     PushScope(Scope::Kind::Block, nullptr);
   }
   return true;
 }
 void ConstructVisitor::Post(const parser::DoConstruct &x) {
   if (x.IsDoConcurrent()) {
     PopScope();
   }
 }
 
 bool ConstructVisitor::Pre(const parser::ForallConstruct &) {
   PushScope(Scope::Kind::Forall, nullptr);
   return true;
 }
 void ConstructVisitor::Post(const parser::ForallConstruct &) { PopScope(); }
 bool ConstructVisitor::Pre(const parser::ForallStmt &) {
   PushScope(Scope::Kind::Forall, nullptr);
   return true;
 }
 void ConstructVisitor::Post(const parser::ForallStmt &) { PopScope(); }
 
 bool ConstructVisitor::Pre(const parser::BlockStmt &x) {
   CheckDef(x.v);
   PushScope(Scope::Kind::Block, nullptr);
   return false;
 }
 bool ConstructVisitor::Pre(const parser::EndBlockStmt &x) {
   PopScope();
   CheckRef(x.v);
   return false;
 }
 
 void ConstructVisitor::Post(const parser::Selector &x) {
   GetCurrentAssociation().selector = ResolveSelector(x);
 }
 
 bool ConstructVisitor::Pre(const parser::AssociateStmt &x) {
   CheckDef(x.t);
   PushScope(Scope::Kind::Block, nullptr);
   PushAssociation();
   return true;
 }
 void ConstructVisitor::Post(const parser::EndAssociateStmt &x) {
   PopAssociation();
   PopScope();
   CheckRef(x.v);
 }
 
 void ConstructVisitor::Post(const parser::Association &x) {
   const auto &name{std::get<parser::Name>(x.t)};
   GetCurrentAssociation().name = &name;
   if (auto *symbol{MakeAssocEntity()}) {
     SetTypeFromAssociation(*symbol);
     SetAttrsFromAssociation(*symbol);
   }
   GetCurrentAssociation() = {}; // clean for further parser::Association.
 }
 
 bool ConstructVisitor::Pre(const parser::ChangeTeamStmt &x) {
   CheckDef(x.t);
   PushScope(Scope::Kind::Block, nullptr);
   PushAssociation();
   return true;
 }
 
 void ConstructVisitor::Post(const parser::CoarrayAssociation &x) {
   const auto &decl{std::get<parser::CodimensionDecl>(x.t)};
   const auto &name{std::get<parser::Name>(decl.t)};
   if (auto *symbol{FindInScope(currScope(), name)}) {
     const auto &selector{std::get<parser::Selector>(x.t)};
     if (auto sel{ResolveSelector(selector)}) {
       const Symbol *whole{UnwrapWholeSymbolDataRef(sel.expr)};
       if (!whole || whole->Corank() == 0) {
         Say(sel.source, // C1116
             "Selector in coarray association must name a coarray"_err_en_US);
       } else if (auto dynType{sel.expr->GetType()}) {
         if (!symbol->GetType()) {
           symbol->SetType(ToDeclTypeSpec(std::move(*dynType)));
         }
       }
     }
   }
 }
 
 void ConstructVisitor::Post(const parser::EndChangeTeamStmt &x) {
   PopAssociation();
   PopScope();
   CheckRef(x.t);
 }
 
 bool ConstructVisitor::Pre(const parser::SelectTypeConstruct &) {
   PushAssociation();
   return true;
 }
 
 void ConstructVisitor::Post(const parser::SelectTypeConstruct &) {
   PopAssociation();
 }
 
 void ConstructVisitor::Post(const parser::SelectTypeStmt &x) {
   auto &association{GetCurrentAssociation()};
   if (const std::optional<parser::Name> &name{std::get<1>(x.t)}) {
     // This isn't a name in the current scope, it is in each TypeGuardStmt
     MakePlaceholder(*name, MiscDetails::Kind::SelectTypeAssociateName);
     association.name = &*name;
     auto exprType{association.selector.expr->GetType()};
     if (exprType && !exprType->IsPolymorphic()) { // C1159
       Say(association.selector.source,
           "Selector '%s' in SELECT TYPE statement must be "
           "polymorphic"_err_en_US);
     }
   } else {
     if (const Symbol *
         whole{UnwrapWholeSymbolDataRef(association.selector.expr)}) {
       ConvertToObjectEntity(const_cast<Symbol &>(*whole));
       if (!IsVariableName(*whole)) {
         Say(association.selector.source, // C901
             "Selector is not a variable"_err_en_US);
         association = {};
       }
       if (const DeclTypeSpec * type{whole->GetType()}) {
         if (!type->IsPolymorphic()) { // C1159
           Say(association.selector.source,
               "Selector '%s' in SELECT TYPE statement must be "
               "polymorphic"_err_en_US);
         }
       }
     } else {
       Say(association.selector.source, // C1157
           "Selector is not a named variable: 'associate-name =>' is required"_err_en_US);
       association = {};
     }
   }
 }
 
 void ConstructVisitor::Post(const parser::SelectRankStmt &x) {
   auto &association{GetCurrentAssociation()};
   if (const std::optional<parser::Name> &name{std::get<1>(x.t)}) {
     // This isn't a name in the current scope, it is in each SelectRankCaseStmt
     MakePlaceholder(*name, MiscDetails::Kind::SelectRankAssociateName);
     association.name = &*name;
   }
 }
 
 bool ConstructVisitor::Pre(const parser::SelectTypeConstruct::TypeCase &) {
   PushScope(Scope::Kind::Block, nullptr);
   return true;
 }
 void ConstructVisitor::Post(const parser::SelectTypeConstruct::TypeCase &) {
   PopScope();
 }
 
 bool ConstructVisitor::Pre(const parser::SelectRankConstruct::RankCase &) {
   PushScope(Scope::Kind::Block, nullptr);
   return true;
 }
 void ConstructVisitor::Post(const parser::SelectRankConstruct::RankCase &) {
   PopScope();
 }
 
 void ConstructVisitor::Post(const parser::TypeGuardStmt::Guard &x) {
   if (auto *symbol{MakeAssocEntity()}) {
     if (std::holds_alternative<parser::Default>(x.u)) {
       SetTypeFromAssociation(*symbol);
     } else if (const auto *type{GetDeclTypeSpec()}) {
       symbol->SetType(*type);
     }
     SetAttrsFromAssociation(*symbol);
   }
 }
 
 void ConstructVisitor::Post(const parser::SelectRankCaseStmt::Rank &x) {
   if (auto *symbol{MakeAssocEntity()}) {
     SetTypeFromAssociation(*symbol);
     SetAttrsFromAssociation(*symbol);
     if (const auto *init{std::get_if<parser::ScalarIntConstantExpr>(&x.u)}) {
       if (auto val{EvaluateInt64(context(), *init)}) {
         auto &details{symbol->get<AssocEntityDetails>()};
         details.set_rank(*val);
       }
     }
   }
 }
 
 bool ConstructVisitor::Pre(const parser::SelectRankConstruct &) {
   PushAssociation();
   return true;
 }
 
 void ConstructVisitor::Post(const parser::SelectRankConstruct &) {
   PopAssociation();
 }
 
 bool ConstructVisitor::CheckDef(const std::optional<parser::Name> &x) {
   if (x) {
     MakeSymbol(*x, MiscDetails{MiscDetails::Kind::ConstructName});
   }
   return true;
 }
 
 void ConstructVisitor::CheckRef(const std::optional<parser::Name> &x) {
   if (x) {
     // Just add an occurrence of this name; checking is done in ValidateLabels
     FindSymbol(*x);
   }
 }
 
 // Make a symbol representing an associating entity from current association.
 Symbol *ConstructVisitor::MakeAssocEntity() {
   Symbol *symbol{nullptr};
   auto &association{GetCurrentAssociation()};
   if (association.name) {
     symbol = &MakeSymbol(*association.name, UnknownDetails{});
     if (symbol->has<AssocEntityDetails>() && symbol->owner() == currScope()) {
       Say(*association.name, // C1104
           "The associate name '%s' is already used in this associate statement"_err_en_US);
       return nullptr;
     }
   } else if (const Symbol *
       whole{UnwrapWholeSymbolDataRef(association.selector.expr)}) {
     symbol = &MakeSymbol(whole->name());
   } else {
     return nullptr;
   }
   if (auto &expr{association.selector.expr}) {
     symbol->set_details(AssocEntityDetails{common::Clone(*expr)});
   } else {
     symbol->set_details(AssocEntityDetails{});
   }
   return symbol;
 }
 
 // Set the type of symbol based on the current association selector.
 void ConstructVisitor::SetTypeFromAssociation(Symbol &symbol) {
   auto &details{symbol.get<AssocEntityDetails>()};
   const MaybeExpr *pexpr{&details.expr()};
   if (!*pexpr) {
     pexpr = &GetCurrentAssociation().selector.expr;
   }
   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))));
       } 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{
                         [&](const parser::Expr &expr) {
                           return Selector{expr.source, EvaluateExpr(expr)};
                         },
                         [&](const parser::Variable &var) {
                           return Selector{var.GetSource(), EvaluateExpr(var)};
                         },
                     },
       x.u);
 }
 
 ConstructVisitor::Association &ConstructVisitor::GetCurrentAssociation() {
   CHECK(!associationStack_.empty());
   return associationStack_.back();
 }
 
 void ConstructVisitor::PushAssociation() {
   associationStack_.emplace_back(Association{});
 }
 
 void ConstructVisitor::PopAssociation() {
   CHECK(!associationStack_.empty());
   associationStack_.pop_back();
 }
 
 const DeclTypeSpec &ConstructVisitor::ToDeclTypeSpec(
     evaluate::DynamicType &&type) {
   switch (type.category()) {
     SWITCH_COVERS_ALL_CASES
   case common::TypeCategory::Integer:
   case common::TypeCategory::Real:
   case common::TypeCategory::Complex:
     return context().MakeNumericType(type.category(), type.kind());
   case common::TypeCategory::Logical:
     return context().MakeLogicalType(type.kind());
   case common::TypeCategory::Derived:
     if (type.IsAssumedType()) {
       return currScope().MakeTypeStarType();
     } else if (type.IsUnlimitedPolymorphic()) {
       return currScope().MakeClassStarType();
     } else {
       return currScope().MakeDerivedType(
           type.IsPolymorphic() ? DeclTypeSpec::ClassDerived
                                : DeclTypeSpec::TypeDerived,
           common::Clone(type.GetDerivedTypeSpec())
 
       );
     }
   case common::TypeCategory::Character:
     CRASH_NO_CASE;
   }
 }
 
 const DeclTypeSpec &ConstructVisitor::ToDeclTypeSpec(
     evaluate::DynamicType &&type, MaybeSubscriptIntExpr &&length) {
   CHECK(type.category() == common::TypeCategory::Character);
   if (length) {
     return currScope().MakeCharacterType(
         ParamValue{SomeIntExpr{*std::move(length)}, common::TypeParamAttr::Len},
         KindExpr{type.kind()});
   } else {
     return currScope().MakeCharacterType(
         ParamValue::Deferred(common::TypeParamAttr::Len),
         KindExpr{type.kind()});
   }
 }
 
 // ResolveNamesVisitor implementation
 
 // Ensures that bare undeclared intrinsic procedure names passed as actual
 // arguments get recognized as being intrinsics.
 bool ResolveNamesVisitor::Pre(const parser::ActualArg &arg) {
   if (const auto *expr{std::get_if<Indirection<parser::Expr>>(&arg.u)}) {
     if (const auto *designator{
             std::get_if<Indirection<parser::Designator>>(&expr->value().u)}) {
       if (const auto *dataRef{
               std::get_if<parser::DataRef>(&designator->value().u)}) {
         if (const auto *name{std::get_if<parser::Name>(&dataRef->u)}) {
           NameIsKnownOrIntrinsic(*name);
         }
       }
     }
   }
   return true;
 }
 
 bool ResolveNamesVisitor::Pre(const parser::FunctionReference &x) {
   HandleCall(Symbol::Flag::Function, x.v);
   return false;
 }
 bool ResolveNamesVisitor::Pre(const parser::CallStmt &x) {
   HandleCall(Symbol::Flag::Subroutine, x.v);
   return false;
 }
 
 bool ResolveNamesVisitor::Pre(const parser::ImportStmt &x) {
   auto &scope{currScope()};
   // Check C896 and C899: where IMPORT statements are allowed
   switch (scope.kind()) {
   case Scope::Kind::Module:
     if (scope.IsModule()) {
       Say("IMPORT is not allowed in a module scoping unit"_err_en_US);
       return false;
     } else if (x.kind == common::ImportKind::None) {
       Say("IMPORT,NONE is not allowed in a submodule scoping unit"_err_en_US);
       return false;
     }
     break;
   case Scope::Kind::MainProgram:
     Say("IMPORT is not allowed in a main program scoping unit"_err_en_US);
     return false;
   case Scope::Kind::Subprogram:
     if (scope.parent().IsGlobal()) {
       Say("IMPORT is not allowed in an external subprogram scoping unit"_err_en_US);
       return false;
     }
     break;
   case Scope::Kind::BlockData: // C1415 (in part)
     Say("IMPORT is not allowed in a BLOCK DATA subprogram"_err_en_US);
     return false;
   default:;
   }
   if (auto error{scope.SetImportKind(x.kind)}) {
     Say(std::move(*error));
   }
   for (auto &name : x.names) {
     if (FindSymbol(scope.parent(), name)) {
       scope.add_importName(name.source);
     } else {
       Say(name, "'%s' not found in host scope"_err_en_US);
     }
   }
   prevImportStmt_ = currStmtSource();
   return false;
 }
 
 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(
       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(
       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)};
             if (!name) {
             } else if (!name->symbol->has<ProcEntityDetails>()) {
               ConvertToObjectEntity(*name->symbol);
             } else if (!context().HasError(*name->symbol)) {
               SayWithDecl(*name, *name->symbol,
                   "Cannot reference function '%s' as data"_err_en_US);
             }
             return name;
           },
           [&](const Indirection<parser::CoindexedNamedObject> &y) {
             Walk(y.value().imageSelector);
             return ResolveDataRef(y.value().base);
           },
       },
       x.u);
 }
 
 // If implicit types are allowed, ensure name is in the symbol table.
 // Otherwise, report an error if it hasn't been declared.
 const parser::Name *DeclarationVisitor::ResolveName(const parser::Name &name) {
   if (Symbol * symbol{FindSymbol(name)}) {
     if (CheckUseError(name)) {
       return nullptr; // reported an error
     }
     if (IsUplevelReference(*symbol)) {
       name.symbol = nullptr;
       MakeSymbol(name, HostAssocDetails{*symbol});
     } else if (IsDummy(*symbol) ||
         (!symbol->GetType() && FindCommonBlockContaining(*symbol))) {
       ConvertToObjectEntity(*symbol);
       ApplyImplicitRules(*symbol);
     }
     return &name;
   }
   if (isImplicitNoneType()) {
     Say(name, "No explicit type declared for '%s'"_err_en_US);
     return nullptr;
   }
   // Create the symbol then ensure it is accessible
   MakeSymbol(InclusiveScope(), name.source, Attrs{});
   auto *symbol{FindSymbol(name)};
   if (!symbol) {
     Say(name,
         "'%s' from host scoping unit is not accessible due to IMPORT"_err_en_US);
     return nullptr;
   }
   ConvertToObjectEntity(*symbol);
   ApplyImplicitRules(*symbol);
   return &name;
 }
 
 bool DeclarationVisitor::IsUplevelReference(const Symbol &symbol) {
   const Scope *symbolUnit{FindProgramUnitContaining(symbol)};
   if (symbolUnit == FindProgramUnitContaining(currScope())) {
     return false;
   } else {
     Scope::Kind kind{DEREF(symbolUnit).kind()};
     return kind == Scope::Kind::Subprogram || kind == Scope::Kind::MainProgram;
   }
 }
 
 // base is a part-ref of a derived type; find the named component in its type.
 // Also handles intrinsic type parameter inquiries (%kind, %len) and
 // COMPLEX component references (%re, %im).
 const parser::Name *DeclarationVisitor::FindComponent(
     const parser::Name *base, const parser::Name &component) {
   if (!base || !base->symbol) {
     return nullptr;
   }
   auto &symbol{base->symbol->GetUltimate()};
   if (!symbol.has<AssocEntityDetails>() && !ConvertToObjectEntity(symbol)) {
     SayWithDecl(*base, symbol,
         "'%s' is an invalid base for a component reference"_err_en_US);
     return nullptr;
   }
   auto *type{symbol.GetType()};
   if (!type) {
     return nullptr; // should have already reported error
   }
   if (const IntrinsicTypeSpec * intrinsic{type->AsIntrinsic()}) {
     auto name{component.ToString()};
     auto category{intrinsic->category()};
     MiscDetails::Kind miscKind{MiscDetails::Kind::None};
     if (name == "kind") {
       miscKind = MiscDetails::Kind::KindParamInquiry;
     } else if (category == TypeCategory::Character) {
       if (name == "len") {
         miscKind = MiscDetails::Kind::LenParamInquiry;
       }
     } else if (category == TypeCategory::Complex) {
       if (name == "re") {
         miscKind = MiscDetails::Kind::ComplexPartRe;
       } else if (name == "im") {
         miscKind = MiscDetails::Kind::ComplexPartIm;
       }
     }
     if (miscKind != MiscDetails::Kind::None) {
       MakePlaceholder(component, miscKind);
       return nullptr;
     }
   } else if (const DerivedTypeSpec * derived{type->AsDerived()}) {
     if (const Scope * scope{derived->scope()}) {
       if (Resolve(component, scope->FindComponent(component.source))) {
         if (auto msg{
                 CheckAccessibleComponent(currScope(), *component.symbol)}) {
           context().Say(component.source, *msg);
         }
         return &component;
       } else {
         SayDerivedType(component.source,
             "Component '%s' not found in derived type '%s'"_err_en_US, *scope);
       }
     }
     return nullptr;
   }
   if (symbol.test(Symbol::Flag::Implicit)) {
     Say(*base,
         "'%s' is not an object of derived type; it is implicitly typed"_err_en_US);
   } else {
     SayWithDecl(
         *base, symbol, "'%s' is not an object of derived type"_err_en_US);
   }
   return nullptr;
 }
 
 // C764, C765
 bool DeclarationVisitor::CheckInitialDataTarget(
     const Symbol &pointer, const SomeExpr &expr, SourceName source) {
   auto &context{GetFoldingContext()};
   auto restorer{context.messages().SetLocation(source)};
   auto dyType{evaluate::DynamicType::From(pointer)};
   CHECK(dyType);
   auto designator{evaluate::TypedWrapper<evaluate::Designator>(
       *dyType, evaluate::DataRef{pointer})};
   CHECK(designator);
   return CheckInitialTarget(context, *designator, expr);
 }
 
 void DeclarationVisitor::CheckInitialProcTarget(
     const Symbol &pointer, const parser::Name &target, SourceName source) {
   // C1519 - must be nonelemental external or module procedure,
   // or an unrestricted specific intrinsic function.
   if (const Symbol * targetSym{target.symbol}) {
     const Symbol &ultimate{targetSym->GetUltimate()};
     if (ultimate.attrs().test(Attr::INTRINSIC)) {
     } else if (!ultimate.attrs().test(Attr::EXTERNAL) &&
         ultimate.owner().kind() != Scope::Kind::Module) {
       Say(source,
           "Procedure pointer '%s' initializer '%s' is neither "
           "an external nor a module procedure"_err_en_US,
           pointer.name(), ultimate.name());
     } else if (ultimate.attrs().test(Attr::ELEMENTAL)) {
       Say(source,
           "Procedure pointer '%s' cannot be initialized with the "
           "elemental procedure '%s"_err_en_US,
           pointer.name(), ultimate.name());
     } else {
       // TODO: Check the "shalls" in the 15.4.3.6 paragraphs 7-10.
     }
   }
 }
 
 void DeclarationVisitor::Initialization(const parser::Name &name,
     const parser::Initialization &init, bool inComponentDecl) {
   // Traversal of the initializer was deferred to here so that the
   // symbol being declared can be available for use in the expression, e.g.:
   //   real, parameter :: x = tiny(x)
   if (!name.symbol) {
     return;
   }
   Symbol &ultimate{name.symbol->GetUltimate()};
   if (IsAllocatable(ultimate)) {
     Say(name, "Allocatable component '%s' cannot be initialized"_err_en_US);
     return;
   }
   if (std::holds_alternative<parser::InitialDataTarget>(init.u)) {
     // Defer analysis further to the end of the specification parts so that
     // forward references and attribute checks (e.g., SAVE) work better.
     // TODO: But pointer initializers of components in named constants of
     // derived types may still need more attention.
     return;
   }
   if (auto *details{ultimate.detailsIf<ObjectEntityDetails>()}) {
     // TODO: check C762 - all bounds and type parameters of component
     // are colons or constant expressions if component is initialized
     bool isNullPointer{false};
     std::visit(
         common::visitors{
             [&](const parser::ConstantExpr &expr) {
               NonPointerInitialization(name, expr, inComponentDecl);
             },
             [&](const parser::NullInit &) {
               isNullPointer = true;
               details->set_init(SomeExpr{evaluate::NullPointer{}});
             },
             [&](const parser::InitialDataTarget &) {
               DIE("InitialDataTarget can't appear here");
             },
             [&](const std::list<Indirection<parser::DataStmtValue>> &) {
               // TODO: Need to Walk(init.u); when implementing this case
               if (inComponentDecl) {
                 Say(name,
                     "Component '%s' initialized with DATA statement values"_err_en_US);
               } else {
                 // TODO - DATA statements and DATA-like initialization extension
               }
             },
         },
         init.u);
     if (isNullPointer) {
       if (!IsPointer(ultimate)) {
         Say(name,
             "Non-pointer component '%s' initialized with null pointer"_err_en_US);
       }
     } else if (IsPointer(ultimate)) {
       Say(name,
           "Object pointer component '%s' initialized with non-pointer expression"_err_en_US);
     }
   }
 }
 
 void DeclarationVisitor::PointerInitialization(
     const parser::Name &name, const parser::InitialDataTarget &target) {
   if (name.symbol) {
     Symbol &ultimate{name.symbol->GetUltimate()};
     if (!context().HasError(ultimate)) {
       if (IsPointer(ultimate)) {
         if (auto *details{ultimate.detailsIf<ObjectEntityDetails>()}) {
           CHECK(!details->init());
           Walk(target);
           if (MaybeExpr expr{EvaluateExpr(target)}) {
             CheckInitialDataTarget(ultimate, *expr, target.value().source);
             details->set_init(std::move(*expr));
           }
         }
       } else {
         Say(name,
             "'%s' is not a pointer but is initialized like one"_err_en_US);
         context().SetError(ultimate);
       }
     }
   }
 }
 void DeclarationVisitor::PointerInitialization(
     const parser::Name &name, const parser::ProcPointerInit &target) {
   if (name.symbol) {
     Symbol &ultimate{name.symbol->GetUltimate()};
     if (!context().HasError(ultimate)) {
       if (IsProcedurePointer(ultimate)) {
         auto &details{ultimate.get<ProcEntityDetails>()};
         CHECK(!details.init());
         Walk(target);
         if (const auto *targetName{std::get_if<parser::Name>(&target.u)}) {
           CheckInitialProcTarget(ultimate, *targetName, name.source);
           if (targetName->symbol) {
             details.set_init(*targetName->symbol);
           }
         } else {
           details.set_init(nullptr); // explicit NULL()
         }
       } else {
         Say(name,
             "'%s' is not a procedure pointer but is initialized "
             "like one"_err_en_US);
         context().SetError(ultimate);
       }
     }
   }
 }
 
 void DeclarationVisitor::NonPointerInitialization(const parser::Name &name,
     const parser::ConstantExpr &expr, bool inComponentDecl) {
   if (name.symbol) {
     Symbol &ultimate{name.symbol->GetUltimate()};
     if (!context().HasError(ultimate)) {
       if (IsPointer(ultimate)) {
         Say(name,
             "'%s' is a pointer but is not initialized like one"_err_en_US);
       } else if (auto *details{ultimate.detailsIf<ObjectEntityDetails>()}) {
         CHECK(!details->init());
         Walk(expr);
         // TODO: check C762 - all bounds and type parameters of component
         // are colons or constant expressions if component is initialized
         if (inComponentDecl) {
           // Can't convert to type of component, which might not yet
           // be known; that's done later during instantiation.
           if (MaybeExpr value{EvaluateExpr(expr)}) {
             details->set_init(std::move(*value));
           }
         } else if (MaybeExpr folded{EvaluateConvertedExpr(
                        ultimate, expr, expr.thing.value().source)}) {
           details->set_init(std::move(*folded));
         }
       }
     }
   }
 }
 
 void ResolveNamesVisitor::HandleCall(
     Symbol::Flag procFlag, const parser::Call &call) {
   std::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));
 }
 
 void ResolveNamesVisitor::HandleProcedureName(
     Symbol::Flag flag, const parser::Name &name) {
   CHECK(flag == Symbol::Flag::Function || flag == Symbol::Flag::Subroutine);
   auto *symbol{FindSymbol(NonDerivedTypeScope(), name)};
   if (!symbol) {
     if (IsIntrinsic(name.source)) {
       symbol =
           &MakeSymbol(InclusiveScope(), name.source, Attrs{Attr::INTRINSIC});
     } else {
       symbol = &MakeSymbol(context().globalScope(), name.source, Attrs{});
     }
     Resolve(name, *symbol);
     if (symbol->has<ModuleDetails>()) {
       SayWithDecl(name, *symbol,
           "Use of '%s' as a procedure conflicts with its declaration"_err_en_US);
       return;
     }
     if (!symbol->attrs().test(Attr::INTRINSIC)) {
       if (isImplicitNoneExternal() && !symbol->attrs().test(Attr::EXTERNAL)) {
         Say(name,
             "'%s' is an external procedure without the EXTERNAL"
             " attribute in a scope with IMPLICIT NONE(EXTERNAL)"_err_en_US);
         return;
       }
       MakeExternal(*symbol);
     }
     ConvertToProcEntity(*symbol);
     SetProcFlag(name, *symbol, flag);
   } else if (symbol->has<UnknownDetails>()) {
     DIE("unexpected UnknownDetails");
   } else if (CheckUseError(name)) {
     // error was reported
   } else {
     symbol = &Resolve(name, symbol)->GetUltimate();
     if (ConvertToProcEntity(*symbol) && IsIntrinsic(symbol->name()) &&
         !IsDummy(*symbol)) {
       symbol->attrs().set(Attr::INTRINSIC);
       // 8.2(3): ignore type from intrinsic in type-declaration-stmt
       symbol->get<ProcEntityDetails>().set_interface(ProcInterface{});
     }
     if (!SetProcFlag(name, *symbol, flag)) {
       return; // reported error
     }
     if (IsProcedure(*symbol) || symbol->has<DerivedTypeDetails>() ||
         symbol->has<ObjectEntityDetails>() ||
         symbol->has<AssocEntityDetails>()) {
       // Symbols with DerivedTypeDetails, ObjectEntityDetails and
       // AssocEntityDetails are accepted here as procedure-designators because
       // this means the related FunctionReference are mis-parsed structure
       // constructors or array references that will be fixed later when
       // analyzing expressions.
     } else if (symbol->test(Symbol::Flag::Implicit)) {
       Say(name,
           "Use of '%s' as a procedure conflicts with its implicit definition"_err_en_US);
     } else {
       SayWithDecl(name, *symbol,
           "Use of '%s' as a procedure conflicts with its declaration"_err_en_US);
     }
   }
 }
 
 // Variant of HandleProcedureName() for use while skimming the executable
 // part of a subprogram to catch calls to dummy procedures that are part
 // of the subprogram's interface, and to mark as procedures any symbols
 // that might otherwise have been miscategorized as objects.
 void ResolveNamesVisitor::NoteExecutablePartCall(
     Symbol::Flag flag, const parser::Call &call) {
   auto &designator{std::get<parser::ProcedureDesignator>(call.t)};
   if (const auto *name{std::get_if<parser::Name>(&designator.u)}) {
     // Subtlety: The symbol pointers in the parse tree are not set, because
     // they might end up resolving elsewhere (e.g., construct entities in
     // SELECT TYPE).
     if (Symbol * symbol{currScope().FindSymbol(name->source)}) {
       Symbol::Flag other{flag == Symbol::Flag::Subroutine
               ? Symbol::Flag::Function
               : Symbol::Flag::Subroutine};
       if (!symbol->test(other)) {
         ConvertToProcEntity(*symbol);
         if (symbol->has<ProcEntityDetails>()) {
           symbol->set(flag);
           if (IsDummy(*symbol)) {
             symbol->attrs().set(Attr::EXTERNAL);
           }
           ApplyImplicitRules(*symbol);
         }
       }
     }
   }
 }
 
 // Check and set the Function or Subroutine flag on symbol; false on error.
 bool ResolveNamesVisitor::SetProcFlag(
     const parser::Name &name, Symbol &symbol, Symbol::Flag flag) {
   if (symbol.test(Symbol::Flag::Function) && flag == Symbol::Flag::Subroutine) {
     SayWithDecl(
         name, symbol, "Cannot call function '%s' like a subroutine"_err_en_US);
     return false;
   } else if (symbol.test(Symbol::Flag::Subroutine) &&
       flag == Symbol::Flag::Function) {
     SayWithDecl(
         name, symbol, "Cannot call subroutine '%s' like a function"_err_en_US);
     return false;
   } else if (symbol.has<ProcEntityDetails>()) {
     symbol.set(flag); // in case it hasn't been set yet
     if (flag == Symbol::Flag::Function) {
       ApplyImplicitRules(symbol);
     }
   } else if (symbol.GetType() && flag == Symbol::Flag::Subroutine) {
     SayWithDecl(
         name, symbol, "Cannot call function '%s' like a subroutine"_err_en_US);
   }
   return true;
 }
 
 bool ModuleVisitor::Pre(const parser::AccessStmt &x) {
   Attr accessAttr{AccessSpecToAttr(std::get<parser::AccessSpec>(x.t))};
   if (!currScope().IsModule()) { // C869
     Say(currStmtSource().value(),
         "%s statement may only appear in the specification part of a module"_err_en_US,
         EnumToString(accessAttr));
     return false;
   }
   const auto &accessIds{std::get<std::list<parser::AccessId>>(x.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::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{info.FindInScope(context(), currScope())}) {
                   info.Resolve(&SetAccess(symbolName, accessAttr, symbol));
                 } else if (info.kind().IsName()) {
                   info.Resolve(&SetAccess(symbolName, accessAttr));
                 } else {
                   Say(symbolName, "Generic spec '%s' not found"_err_en_US);
                 }
               },
           },
           accessId.u);
     }
   }
   return false;
 }
 
 // Set the access specification for this symbol.
 Symbol &ModuleVisitor::SetAccess(
     const SourceName &name, Attr attr, Symbol *symbol) {
   if (!symbol) {
     symbol = &MakeSymbol(name);
   }
   Attrs &attrs{symbol->attrs()};
   if (attrs.HasAny({Attr::PUBLIC, Attr::PRIVATE})) {
     // PUBLIC/PRIVATE already set: make it a fatal error if it changed
     Attr prev = attrs.test(Attr::PUBLIC) ? Attr::PUBLIC : Attr::PRIVATE;
     auto msg{IsDefinedOperator(name)
             ? "The accessibility of operator '%s' has already been specified as %s"_en_US
             : "The accessibility of '%s' has already been specified as %s"_en_US};
     Say(name, WithIsFatal(msg, attr != prev), name, EnumToString(prev));
   } else {
     attrs.set(attr);
   }
   return *symbol;
 }
 
 static bool NeedsExplicitType(const Symbol &symbol) {
   if (symbol.has<UnknownDetails>()) {
     return true;
   } else if (const auto *details{symbol.detailsIf<EntityDetails>()}) {
     return !details->type();
   } else if (const auto *details{symbol.detailsIf<ObjectEntityDetails>()}) {
     return !details->type();
   } else if (const auto *details{symbol.detailsIf<ProcEntityDetails>()}) {
     return !details->interface().symbol() && !details->interface().type();
   } else {
     return false;
   }
 }
 
 bool ResolveNamesVisitor::Pre(const parser::SpecificationPart &x) {
   Walk(std::get<0>(x.t));
   Walk(std::get<1>(x.t));
   Walk(std::get<2>(x.t));
   Walk(std::get<3>(x.t));
   Walk(std::get<4>(x.t));
   const std::list<parser::DeclarationConstruct> &decls{std::get<5>(x.t)};
   for (const auto &decl : decls) {
     if (const auto *spec{
             std::get_if<parser::SpecificationConstruct>(&decl.u)}) {
       PreSpecificationConstruct(*spec);
     }
   }
   Walk(decls);
   FinishSpecificationPart(decls);
   return false;
 }
 
 // Initial processing on specification constructs, before visiting them.
 void ResolveNamesVisitor::PreSpecificationConstruct(
     const parser::SpecificationConstruct &spec) {
   std::visit(
       common::visitors{
           [&](const Indirection<parser::DerivedTypeDef> &) {},
           [&](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)};
             const auto *spec{std::get_if<std::optional<parser::GenericSpec>>(
                 &stmt.statement.u)};
             if (spec && *spec) {
               CreateGeneric(**spec);
             }
           },
           [&](const auto &) {},
       },
       spec.u);
 }
 
 void ResolveNamesVisitor::CreateGeneric(const parser::GenericSpec &x) {
   auto info{GenericSpecInfo{x}};
   const SourceName &symbolName{info.symbolName()};
   if (IsLogicalConstant(context(), symbolName)) {
     Say(symbolName,
         "Logical constant '%s' may not be used as a defined operator"_err_en_US);
     return;
   }
   GenericDetails genericDetails;
   if (Symbol * existing{info.FindInScope(context(), currScope())}) {
     if (existing->has<GenericDetails>()) {
       info.Resolve(existing);
       return; // already have generic, add to it
     }
     Symbol &ultimate{existing->GetUltimate()};
     if (auto *ultimateDetails{ultimate.detailsIf<GenericDetails>()}) {
       genericDetails.CopyFrom(*ultimateDetails);
     } else if (ultimate.has<SubprogramDetails>() ||
         ultimate.has<SubprogramNameDetails>()) {
       genericDetails.set_specific(ultimate);
     } else if (ultimate.has<DerivedTypeDetails>()) {
       genericDetails.set_derivedType(ultimate);
     } else {
       SayAlreadyDeclared(symbolName, *existing);
     }
     EraseSymbol(*existing);
   }
   info.Resolve(&MakeSymbol(symbolName, Attrs{}, std::move(genericDetails)));
 }
 
 void ResolveNamesVisitor::FinishSpecificationPart(
     const std::list<parser::DeclarationConstruct> &decls) {
   badStmtFuncFound_ = false;
   CheckImports();
   bool inModule{currScope().kind() == Scope::Kind::Module};
   for (auto &pair : currScope()) {
     auto &symbol{*pair.second};
     if (NeedsExplicitType(symbol)) {
       ApplyImplicitRules(symbol);
     }
     if (symbol.has<GenericDetails>()) {
       CheckGenericProcedures(symbol);
     }
     if (inModule && symbol.attrs().test(Attr::EXTERNAL) &&
         !symbol.test(Symbol::Flag::Function) &&
         !symbol.test(Symbol::Flag::Subroutine)) {
       // in a module, external proc without return type is subroutine
       symbol.set(
           symbol.GetType() ? Symbol::Flag::Function : Symbol::Flag::Subroutine);
     }
   }
   currScope().InstantiateDerivedTypes(context());
   for (const auto &decl : decls) {
     if (const auto *statement{std::get_if<
             parser::Statement<common::Indirection<parser::StmtFunctionStmt>>>(
             &decl.u)}) {
       AnalyzeStmtFunctionStmt(statement->statement.value());
     }
   }
   // TODO: what about instantiations in BLOCK?
   CheckSaveStmts();
   CheckCommonBlocks();
   CheckEquivalenceSets();
 }
 
 // Analyze the bodies of statement functions now that the symbols in this
 // specification part have been fully declared and implicitly typed.
 void ResolveNamesVisitor::AnalyzeStmtFunctionStmt(
     const parser::StmtFunctionStmt &stmtFunc) {
   Symbol *symbol{std::get<parser::Name>(stmtFunc.t).symbol};
   if (!symbol || !symbol->has<SubprogramDetails>()) {
     return;
   }
   auto &details{symbol->get<SubprogramDetails>()};
   auto expr{AnalyzeExpr(
       context(), std::get<parser::Scalar<parser::Expr>>(stmtFunc.t))};
   if (!expr) {
     context().SetError(*symbol);
     return;
   }
   if (auto type{evaluate::DynamicType::From(*symbol)}) {
     auto converted{ConvertToType(*type, std::move(*expr))};
     if (!converted) {
       context().SetError(*symbol);
       return;
     }
     details.set_stmtFunction(std::move(*converted));
   } else {
     details.set_stmtFunction(std::move(*expr));
   }
 }
 
 void ResolveNamesVisitor::CheckImports() {
   auto &scope{currScope()};
   switch (scope.GetImportKind()) {
   case common::ImportKind::None:
     break;
   case common::ImportKind::All:
     // C8102: all entities in host must not be hidden
     for (const auto &pair : scope.parent()) {
       auto &name{pair.first};
       std::optional<SourceName> scopeName{scope.GetName()};
       if (!scopeName || name != *scopeName) {
         CheckImport(prevImportStmt_.value(), name);
       }
     }
     break;
   case common::ImportKind::Default:
   case common::ImportKind::Only:
     // C8102: entities named in IMPORT must not be hidden
     for (auto &name : scope.importNames()) {
       CheckImport(name, name);
     }
     break;
   }
 }
 
 void ResolveNamesVisitor::CheckImport(
     const SourceName &location, const SourceName &name) {
   if (auto *symbol{FindInScope(currScope(), name)}) {
     Say(location, "'%s' from host is not accessible"_err_en_US, name)
         .Attach(symbol->name(), "'%s' is hidden by this entity"_en_US,
             symbol->name());
   }
 }
 
 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{
                  [&](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{
                  [&](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);
   Walk(bounds);
   // Resolve unrestricted specific intrinsic procedures as in "p => cos".
   if (const parser::Name * name{parser::Unwrap<parser::Name>(expr)}) {
     if (NameIsKnownOrIntrinsic(*name)) {
       return false;
     }
   }
   Walk(expr);
   return false;
 }
 void ResolveNamesVisitor::Post(const parser::Designator &x) {
   ResolveDesignator(x);
 }
 
 void ResolveNamesVisitor::Post(const parser::ProcComponentRef &x) {
   ResolveStructureComponent(x.v.thing);
 }
 void ResolveNamesVisitor::Post(const parser::TypeGuardStmt &x) {
   DeclTypeSpecVisitor::Post(x);
   ConstructVisitor::Post(x);
 }
 bool ResolveNamesVisitor::Pre(const parser::StmtFunctionStmt &x) {
   CheckNotInBlock("STATEMENT FUNCTION"); // C1107
   if (HandleStmtFunction(x)) {
     return false;
   } else {
     // This is an array element assignment: resolve names of indices
     const auto &names{std::get<std::list<parser::Name>>(x.t)};
     for (auto &name : names) {
       ResolveName(name);
     }
     return true;
   }
 }
 
 bool ResolveNamesVisitor::Pre(const parser::DefinedOpName &x) {
   const parser::Name &name{x.v};
   if (FindSymbol(name)) {
     // OK
   } else if (IsLogicalConstant(context(), name.source)) {
     Say(name,
         "Logical constant '%s' may not be used as a defined operator"_err_en_US);
   } else {
     // Resolved later in expression semantics
     MakePlaceholder(name, MiscDetails::Kind::TypeBoundDefinedOp);
   }
   return false;
 }
 
 void ResolveNamesVisitor::Post(const parser::AssignStmt &x) {
   if (auto *name{ResolveName(std::get<parser::Name>(x.t))}) {
     ConvertToObjectEntity(DEREF(name->symbol));
   }
 }
 void ResolveNamesVisitor::Post(const parser::AssignedGotoStmt &x) {
   if (auto *name{ResolveName(std::get<parser::Name>(x.t))}) {
     ConvertToObjectEntity(DEREF(name->symbol));
   }
 }
 
 bool ResolveNamesVisitor::Pre(const parser::ProgramUnit &x) {
   auto root{ProgramTree::Build(x)};
   SetScope(context().globalScope());
   ResolveSpecificationParts(root);
   FinishSpecificationParts(root);
   inExecutionPart_ = true;
   ResolveExecutionParts(root);
   inExecutionPart_ = false;
   ResolveAccParts(context(), x);
   ResolveOmpParts(context(), x);
   return false;
 }
 
 // References to procedures need to record that their symbols are known
 // to be procedures, so that they don't get converted to objects by default.
 class ExecutionPartSkimmer {
 public:
   explicit ExecutionPartSkimmer(ResolveNamesVisitor &resolver)
       : resolver_{resolver} {}
 
   void Walk(const parser::ExecutionPart *exec) {
     if (exec) {
       parser::Walk(*exec, *this);
     }
   }
 
   template <typename A> bool Pre(const A &) { return true; }
   template <typename A> void Post(const A &) {}
   void Post(const parser::FunctionReference &fr) {
     resolver_.NoteExecutablePartCall(Symbol::Flag::Function, fr.v);
   }
   void Post(const parser::CallStmt &cs) {
     resolver_.NoteExecutablePartCall(Symbol::Flag::Subroutine, cs.v);
   }
 
 private:
   ResolveNamesVisitor &resolver_;
 };
 
 // Build the scope tree and resolve names in the specification parts of this
 // node and its children
 void ResolveNamesVisitor::ResolveSpecificationParts(ProgramTree &node) {
   if (node.isSpecificationPartResolved()) {
     return; // been here already
   }
   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(
       [&](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
   // result from being converted later to a function symbol if it is called
   // inside the function.
   // If the result is function pointer, then ConvertToObjectEntity will not
   // convert the result to an object, and calling the symbol inside the function
   // will result in calls to the result pointer.
   // A function cannot be called recursively if RESULT was not used to define a
   // distinct result name (15.6.2.2 point 4.).
   if (Symbol * symbol{scope.symbol()}) {
     if (auto *details{symbol->detailsIf<SubprogramDetails>()}) {
       if (details->isFunction()) {
         ConvertToObjectEntity(const_cast<Symbol &>(details->result()));
       }
     }
   }
   if (node.IsModule()) {
     ApplyDefaultAccess();
   }
   for (auto &child : node.children()) {
     ResolveSpecificationParts(child);
   }
   ExecutionPartSkimmer{*this}.Walk(node.exec());
   PopScope();
   // Ensure that every object entity has a type.
   for (auto &pair : *node.scope()) {
     ApplyImplicitRules(*pair.second);
   }
 }
 
 // Add SubprogramNameDetails symbols for module and internal subprograms
 void ResolveNamesVisitor::AddSubpNames(ProgramTree &node) {
   auto kind{
       node.IsModule() ? SubprogramKind::Module : SubprogramKind::Internal};
   for (auto &child : node.children()) {
     auto &symbol{MakeSymbol(child.name(), SubprogramNameDetails{kind, child})};
     symbol.set(child.GetSubpFlag());
   }
 }
 
 // Push a new scope for this node or return false on error.
 bool ResolveNamesVisitor::BeginScopeForNode(const ProgramTree &node) {
   switch (node.GetKind()) {
     SWITCH_COVERS_ALL_CASES
   case ProgramTree::Kind::Program:
     PushScope(Scope::Kind::MainProgram,
         &MakeSymbol(node.name(), MainProgramDetails{}));
     return true;
   case ProgramTree::Kind::Function:
   case ProgramTree::Kind::Subroutine:
     return BeginSubprogram(
         node.name(), node.GetSubpFlag(), node.HasModulePrefix());
   case ProgramTree::Kind::MpSubprogram:
     return BeginMpSubprogram(node.name());
   case ProgramTree::Kind::Module:
     BeginModule(node.name(), false);
     return true;
   case ProgramTree::Kind::Submodule:
     return BeginSubmodule(node.name(), node.GetParentId());
   case ProgramTree::Kind::BlockData:
     PushBlockDataScope(node.name());
     return true;
   }
 }
 
 // Some analyses and checks, such as the processing of initializers of
 // pointers, are deferred until all of the pertinent specification parts
 // have been visited.  This deferred processing enables the use of forward
 // references in these circumstances.
 class DeferredCheckVisitor {
 public:
   explicit DeferredCheckVisitor(ResolveNamesVisitor &resolver)
       : resolver_{resolver} {}
 
   template <typename A> void Walk(const A &x) { parser::Walk(x, *this); }
 
   template <typename A> bool Pre(const A &) { return true; }
   template <typename A> void Post(const A &) {}
 
   void Post(const parser::DerivedTypeStmt &x) {
     const auto &name{std::get<parser::Name>(x.t)};
     if (Symbol * symbol{name.symbol}) {
       if (Scope * scope{symbol->scope()}) {
         if (scope->IsDerivedType()) {
           resolver_.PushScope(*scope);
           pushedScope_ = true;
         }
       }
     }
   }
   void Post(const parser::EndTypeStmt &) {
     if (pushedScope_) {
       resolver_.PopScope();
       pushedScope_ = false;
     }
   }
 
   void Post(const parser::ProcInterface &pi) {
     if (const auto *name{std::get_if<parser::Name>(&pi.u)}) {
       resolver_.CheckExplicitInterface(*name);
     }
   }
   bool Pre(const parser::EntityDecl &decl) {
     Init(std::get<parser::Name>(decl.t),
         std::get<std::optional<parser::Initialization>>(decl.t));
     return false;
   }
   bool Pre(const parser::ComponentDecl &decl) {
     Init(std::get<parser::Name>(decl.t),
         std::get<std::optional<parser::Initialization>>(decl.t));
     return false;
   }
   bool Pre(const parser::ProcDecl &decl) {
     if (const auto &init{
             std::get<std::optional<parser::ProcPointerInit>>(decl.t)}) {
       resolver_.PointerInitialization(std::get<parser::Name>(decl.t), *init);
     }
     return false;
   }
   void Post(const parser::TypeBoundProcedureStmt::WithInterface &tbps) {
     resolver_.CheckExplicitInterface(tbps.interfaceName);
   }
   void Post(const parser::TypeBoundProcedureStmt::WithoutInterface &tbps) {
     if (pushedScope_) {
       resolver_.CheckBindings(tbps);
     }
   }
 
 private:
   void Init(const parser::Name &name,
       const std::optional<parser::Initialization> &init) {
     if (init) {
       if (const auto *target{
               std::get_if<parser::InitialDataTarget>(&init->u)}) {
         resolver_.PointerInitialization(name, *target);
       }
     }
   }
 
   ResolveNamesVisitor &resolver_;
   bool pushedScope_{false};
 };
 
 // Perform checks and completions that need to happen after all of
 // the specification parts but before any of the execution parts.
 void ResolveNamesVisitor::FinishSpecificationParts(const ProgramTree &node) {
   if (!node.scope()) {
     return; // error occurred creating scope
   }
   SetScope(*node.scope());
   // The initializers of pointers, pointer components, and non-deferred
   // type-bound procedure bindings have not yet been traversed.
   // We do that now, when any (formerly) forward references that appear
   // in those initializers will resolve to the right symbols.
   DeferredCheckVisitor{*this}.Walk(node.spec());
   DeferredCheckVisitor{*this}.Walk(node.exec()); // for BLOCK
   for (Scope &childScope : currScope().children()) {
     if (childScope.IsDerivedType() && !childScope.symbol()) {
       FinishDerivedTypeInstantiation(childScope);
     }
   }
   for (const auto &child : node.children()) {
     FinishSpecificationParts(child);
   }
 }
 
 // Fold object pointer initializer designators with the actual
 // type parameter values of a particular instantiation.
 void ResolveNamesVisitor::FinishDerivedTypeInstantiation(Scope &scope) {
   CHECK(scope.IsDerivedType() && !scope.symbol());
   if (DerivedTypeSpec * spec{scope.derivedTypeSpec()}) {
     spec->Instantiate(currScope(), context());
     const Symbol &origTypeSymbol{spec->typeSymbol()};
     if (const Scope * origTypeScope{origTypeSymbol.scope()}) {
       CHECK(origTypeScope->IsDerivedType() &&
           origTypeScope->symbol() == &origTypeSymbol);
       auto &foldingContext{GetFoldingContext()};
       auto restorer{foldingContext.WithPDTInstance(*spec)};
       for (auto &pair : scope) {
         Symbol &comp{*pair.second};
         const Symbol &origComp{DEREF(FindInScope(*origTypeScope, comp.name()))};
         if (IsPointer(comp)) {
           if (auto *details{comp.detailsIf<ObjectEntityDetails>()}) {
             auto origDetails{origComp.get<ObjectEntityDetails>()};
             if (const MaybeExpr & init{origDetails.init()}) {
               SomeExpr newInit{*init};
               MaybeExpr folded{
                   evaluate::Fold(foldingContext, std::move(newInit))};
               details->set_init(std::move(folded));
             }
           }
         }
       }
     }
   }
 }
 
 // Resolve names in the execution part of this node and its children
 void ResolveNamesVisitor::ResolveExecutionParts(const ProgramTree &node) {
   if (!node.scope()) {
     return; // error occurred creating scope
   }
   SetScope(*node.scope());
   if (const auto *exec{node.exec()}) {
     Walk(*exec);
   }
   PopScope(); // converts unclassified entities into objects
   for (const auto &child : node.children()) {
     ResolveExecutionParts(child);
   }
 }
 
 void ResolveNamesVisitor::Post(const parser::Program &) {
   // ensure that all temps were deallocated
   CHECK(!attrs_);
   CHECK(!GetDeclTypeSpec());
 }
 
 // A singleton instance of the scope -> IMPLICIT rules mapping is
 // shared by all instances of ResolveNamesVisitor and accessed by this
 // pointer when the visitors (other than the top-level original) are
 // constructed.
 static ImplicitRulesMap *sharedImplicitRulesMap{nullptr};
 
 bool ResolveNames(SemanticsContext &context, const parser::Program &program) {
   ImplicitRulesMap implicitRulesMap;
   auto restorer{common::ScopedSet(sharedImplicitRulesMap, &implicitRulesMap)};
   ResolveNamesVisitor{context, implicitRulesMap}.Walk(program);
   return !context.AnyFatalError();
 }
 
 // Processes a module (but not internal) function when it is referenced
 // in a specification expression in a sibling procedure.
 void ResolveSpecificationParts(
     SemanticsContext &context, const Symbol &subprogram) {
   auto originalLocation{context.location()};
   ResolveNamesVisitor visitor{context, DEREF(sharedImplicitRulesMap)};
   ProgramTree &node{subprogram.get<SubprogramNameDetails>().node()};
   const Scope &moduleScope{subprogram.owner()};
   visitor.SetScope(const_cast<Scope &>(moduleScope));
   visitor.ResolveSpecificationParts(node);
   context.set_location(std::move(originalLocation));
 }
 
 } // namespace Fortran::semantics
diff --git a/flang/unittests/Evaluate/intrinsics.cpp b/flang/unittests/Evaluate/intrinsics.cpp
index 7b8895b8da4c..3b9805946286 100644
--- a/flang/unittests/Evaluate/intrinsics.cpp
+++ b/flang/unittests/Evaluate/intrinsics.cpp
@@ -1,338 +1,338 @@
 #include "flang/Evaluate/intrinsics.h"
 #include "testing.h"
 #include "flang/Evaluate/common.h"
 #include "flang/Evaluate/expression.h"
 #include "flang/Evaluate/tools.h"
 #include "flang/Parser/provenance.h"
 #include "llvm/Support/raw_ostream.h"
 #include <initializer_list>
 #include <map>
 #include <string>
 
 namespace Fortran::evaluate {
 
 class CookedStrings {
 public:
   CookedStrings() {}
   explicit CookedStrings(const std::initializer_list<std::string> &ss) {
     for (const auto &s : ss) {
       Save(s);
     }
     Marshal();
   }
   void Save(const std::string &s) {
     offsets_[s] = cooked_.Put(s);
     cooked_.PutProvenance(cooked_.allSources().AddCompilerInsertion(s));
   }
   void Marshal() { cooked_.Marshal(); }
   parser::CharBlock operator()(const std::string &s) {
     return {cooked_.data().data() + offsets_[s], s.size()};
   }
   parser::ContextualMessages Messages(parser::Messages &buffer) {
     return parser::ContextualMessages{cooked_.data(), &buffer};
   }
   void Emit(llvm::raw_ostream &o, const parser::Messages &messages) {
     messages.Emit(o, cooked_);
   }
 
 private:
   parser::AllSources allSources_;
   parser::CookedSource cooked_{allSources_};
   std::map<std::string, std::size_t> offsets_;
 };
 
 template <typename A> auto Const(A &&x) -> Constant<TypeOf<A>> {
   return Constant<TypeOf<A>>{std::move(x)};
 }
 
 template <typename A> struct NamedArg {
   std::string keyword;
   A value;
 };
 
 template <typename A> static NamedArg<A> Named(std::string kw, A &&x) {
   return {kw, std::move(x)};
 }
 
 struct TestCall {
   TestCall(const common::IntrinsicTypeDefaultKinds &d,
       const IntrinsicProcTable &t, std::string n)
       : defaults{d}, table{t}, name{n} {}
   template <typename A> TestCall &Push(A &&x) {
     args.emplace_back(AsGenericExpr(std::move(x)));
     keywords.push_back("");
     return *this;
   }
   template <typename A> TestCall &Push(NamedArg<A> &&x) {
     args.emplace_back(AsGenericExpr(std::move(x.value)));
     keywords.push_back(x.keyword);
     strings.Save(x.keyword);
     return *this;
   }
-  template <typename A, typename... As> TestCall &Push(A &&x, As &&... xs) {
+  template <typename A, typename... As> TestCall &Push(A &&x, As &&...xs) {
     Push(std::move(x));
     return Push(std::move(xs)...);
   }
   void Marshal() {
     strings.Save(name);
     strings.Marshal();
     std::size_t j{0};
     for (auto &kw : keywords) {
       if (!kw.empty()) {
         args[j]->set_keyword(strings(kw));
       }
       ++j;
     }
   }
   void DoCall(std::optional<DynamicType> resultType = std::nullopt,
       int rank = 0, bool isElemental = false) {
     Marshal();
     parser::CharBlock fName{strings(name)};
     llvm::outs() << "function: " << fName.ToString();
     char sep{'('};
     for (const auto &a : args) {
       llvm::outs() << sep;
       sep = ',';
       a->AsFortran(llvm::outs());
     }
     if (sep == '(') {
       llvm::outs() << '(';
     }
     llvm::outs() << ')' << '\n';
     llvm::outs().flush();
     CallCharacteristics call{fName.ToString()};
     auto messages{strings.Messages(buffer)};
     FoldingContext context{messages, defaults, table};
     std::optional<SpecificCall> si{table.Probe(call, args, context)};
     if (resultType.has_value()) {
       TEST(si.has_value());
       TEST(messages.messages() && !messages.messages()->AnyFatalError());
       if (si) {
         const auto &proc{si->specificIntrinsic.characteristics.value()};
         const auto &fr{proc.functionResult};
         TEST(fr.has_value());
         if (fr) {
           const auto *ts{fr->GetTypeAndShape()};
           TEST(ts != nullptr);
           if (ts) {
             TEST(*resultType == ts->type());
             MATCH(rank, ts->Rank());
           }
         }
         MATCH(isElemental,
             proc.attrs.test(characteristics::Procedure::Attr::Elemental));
       }
     } else {
       TEST(!si.has_value());
       TEST((messages.messages() && messages.messages()->AnyFatalError()) ||
           name == "bad");
     }
     strings.Emit(llvm::outs(), buffer);
   }
 
   const common::IntrinsicTypeDefaultKinds &defaults;
   const IntrinsicProcTable &table;
   CookedStrings strings;
   parser::Messages buffer;
   ActualArguments args;
   std::string name;
   std::vector<std::string> keywords;
 };
 
 void TestIntrinsics() {
   common::IntrinsicTypeDefaultKinds defaults;
   MATCH(4, defaults.GetDefaultKind(TypeCategory::Integer));
   MATCH(4, defaults.GetDefaultKind(TypeCategory::Real));
   IntrinsicProcTable table{IntrinsicProcTable::Configure(defaults)};
   table.Dump(llvm::outs());
 
   using Int1 = Type<TypeCategory::Integer, 1>;
   using Int4 = Type<TypeCategory::Integer, 4>;
   using Int8 = Type<TypeCategory::Integer, 8>;
   using Real4 = Type<TypeCategory::Real, 4>;
   using Real8 = Type<TypeCategory::Real, 8>;
   using Complex4 = Type<TypeCategory::Complex, 4>;
   using Complex8 = Type<TypeCategory::Complex, 8>;
   using Char = Type<TypeCategory::Character, 1>;
   using Log4 = Type<TypeCategory::Logical, 4>;
 
   TestCall{defaults, table, "bad"}
       .Push(Const(Scalar<Int4>{}))
       .DoCall(); // bad intrinsic name
   TestCall{defaults, table, "abs"}
       .Push(Named("a", Const(Scalar<Int4>{})))
       .DoCall(Int4::GetType());
   TestCall{defaults, table, "abs"}
       .Push(Const(Scalar<Int4>{}))
       .DoCall(Int4::GetType());
   TestCall{defaults, table, "abs"}
       .Push(Named("bad", Const(Scalar<Int4>{})))
       .DoCall(); // bad keyword
   TestCall{defaults, table, "abs"}.DoCall(); // insufficient args
   TestCall{defaults, table, "abs"}
       .Push(Const(Scalar<Int4>{}))
       .Push(Const(Scalar<Int4>{}))
       .DoCall(); // too many args
   TestCall{defaults, table, "abs"}
       .Push(Const(Scalar<Int4>{}))
       .Push(Named("a", Const(Scalar<Int4>{})))
       .DoCall();
   TestCall{defaults, table, "abs"}
       .Push(Named("a", Const(Scalar<Int4>{})))
       .Push(Const(Scalar<Int4>{}))
       .DoCall();
   TestCall{defaults, table, "abs"}
       .Push(Const(Scalar<Int1>{}))
       .DoCall(Int1::GetType());
   TestCall{defaults, table, "abs"}
       .Push(Const(Scalar<Int4>{}))
       .DoCall(Int4::GetType());
   TestCall{defaults, table, "abs"}
       .Push(Const(Scalar<Int8>{}))
       .DoCall(Int8::GetType());
   TestCall{defaults, table, "abs"}
       .Push(Const(Scalar<Real4>{}))
       .DoCall(Real4::GetType());
   TestCall{defaults, table, "abs"}
       .Push(Const(Scalar<Real8>{}))
       .DoCall(Real8::GetType());
   TestCall{defaults, table, "abs"}
       .Push(Const(Scalar<Complex4>{}))
       .DoCall(Real4::GetType());
   TestCall{defaults, table, "abs"}
       .Push(Const(Scalar<Complex8>{}))
       .DoCall(Real8::GetType());
   TestCall{defaults, table, "abs"}.Push(Const(Scalar<Char>{})).DoCall();
   TestCall{defaults, table, "abs"}.Push(Const(Scalar<Log4>{})).DoCall();
 
   // "Ext" in names for calls allowed as extensions
   TestCall maxCallR{defaults, table, "max"}, maxCallI{defaults, table, "min"},
       max0Call{defaults, table, "max0"}, max1Call{defaults, table, "max1"},
       amin0Call{defaults, table, "amin0"}, amin1Call{defaults, table, "amin1"},
       max0ExtCall{defaults, table, "max0"},
       amin1ExtCall{defaults, table, "amin1"};
   for (int j{0}; j < 10; ++j) {
     maxCallR.Push(Const(Scalar<Real4>{}));
     maxCallI.Push(Const(Scalar<Int4>{}));
     max0Call.Push(Const(Scalar<Int4>{}));
     max0ExtCall.Push(Const(Scalar<Real4>{}));
     max1Call.Push(Const(Scalar<Real4>{}));
     amin0Call.Push(Const(Scalar<Int4>{}));
     amin1ExtCall.Push(Const(Scalar<Int4>{}));
     amin1Call.Push(Const(Scalar<Real4>{}));
   }
   maxCallR.DoCall(Real4::GetType());
   maxCallI.DoCall(Int4::GetType());
   max0Call.DoCall(Int4::GetType());
   max0ExtCall.DoCall(Int4::GetType());
   max1Call.DoCall(Int4::GetType());
   amin0Call.DoCall(Real4::GetType());
   amin1Call.DoCall(Real4::GetType());
   amin1ExtCall.DoCall(Real4::GetType());
 
   TestCall{defaults, table, "conjg"}
       .Push(Const(Scalar<Complex4>{}))
       .DoCall(Complex4::GetType());
   TestCall{defaults, table, "conjg"}
       .Push(Const(Scalar<Complex8>{}))
       .DoCall(Complex8::GetType());
   TestCall{defaults, table, "dconjg"}.Push(Const(Scalar<Complex4>{})).DoCall();
   TestCall{defaults, table, "dconjg"}
       .Push(Const(Scalar<Complex8>{}))
       .DoCall(Complex8::GetType());
 
   TestCall{defaults, table, "float"}.Push(Const(Scalar<Real4>{})).DoCall();
   TestCall{defaults, table, "float"}
       .Push(Const(Scalar<Int4>{}))
       .DoCall(Real4::GetType());
   TestCall{defaults, table, "idint"}.Push(Const(Scalar<Int4>{})).DoCall();
   TestCall{defaults, table, "idint"}
       .Push(Const(Scalar<Real8>{}))
       .DoCall(Int4::GetType());
 
   // Allowed as extensions
   TestCall{defaults, table, "float"}
       .Push(Const(Scalar<Int8>{}))
       .DoCall(Real4::GetType());
   TestCall{defaults, table, "idint"}
       .Push(Const(Scalar<Real4>{}))
       .DoCall(Int4::GetType());
 
   TestCall{defaults, table, "num_images"}.DoCall(Int4::GetType());
   TestCall{defaults, table, "num_images"}
       .Push(Const(Scalar<Int1>{}))
       .DoCall(Int4::GetType());
   TestCall{defaults, table, "num_images"}
       .Push(Const(Scalar<Int4>{}))
       .DoCall(Int4::GetType());
   TestCall{defaults, table, "num_images"}
       .Push(Const(Scalar<Int8>{}))
       .DoCall(Int4::GetType());
   TestCall{defaults, table, "num_images"}
       .Push(Named("team_number", Const(Scalar<Int4>{})))
       .DoCall(Int4::GetType());
   TestCall{defaults, table, "num_images"}
       .Push(Const(Scalar<Int4>{}))
       .Push(Const(Scalar<Int4>{}))
       .DoCall(); // too many args
   TestCall{defaults, table, "num_images"}
       .Push(Named("bad", Const(Scalar<Int4>{})))
       .DoCall(); // bad keyword
   TestCall{defaults, table, "num_images"}
       .Push(Const(Scalar<Char>{}))
       .DoCall(); // bad type
   TestCall{defaults, table, "num_images"}
       .Push(Const(Scalar<Log4>{}))
       .DoCall(); // bad type
   TestCall{defaults, table, "num_images"}
       .Push(Const(Scalar<Complex8>{}))
       .DoCall(); // bad type
   TestCall{defaults, table, "num_images"}
       .Push(Const(Scalar<Real4>{}))
       .DoCall(); // bad type
 
   // TODO: test other intrinsics
 
   // Test unrestricted specific to generic name mapping (table 16.2).
   TEST(table.GetGenericIntrinsicName("alog") == "log");
   TEST(table.GetGenericIntrinsicName("alog10") == "log10");
   TEST(table.GetGenericIntrinsicName("amod") == "mod");
   TEST(table.GetGenericIntrinsicName("cabs") == "abs");
   TEST(table.GetGenericIntrinsicName("ccos") == "cos");
   TEST(table.GetGenericIntrinsicName("cexp") == "exp");
   TEST(table.GetGenericIntrinsicName("clog") == "log");
   TEST(table.GetGenericIntrinsicName("csin") == "sin");
   TEST(table.GetGenericIntrinsicName("csqrt") == "sqrt");
   TEST(table.GetGenericIntrinsicName("dabs") == "abs");
   TEST(table.GetGenericIntrinsicName("dacos") == "acos");
   TEST(table.GetGenericIntrinsicName("dasin") == "asin");
   TEST(table.GetGenericIntrinsicName("datan") == "atan");
   TEST(table.GetGenericIntrinsicName("datan2") == "atan2");
   TEST(table.GetGenericIntrinsicName("dcos") == "cos");
   TEST(table.GetGenericIntrinsicName("dcosh") == "cosh");
   TEST(table.GetGenericIntrinsicName("ddim") == "dim");
   TEST(table.GetGenericIntrinsicName("dexp") == "exp");
   TEST(table.GetGenericIntrinsicName("dint") == "aint");
   TEST(table.GetGenericIntrinsicName("dlog") == "log");
   TEST(table.GetGenericIntrinsicName("dlog10") == "log10");
   TEST(table.GetGenericIntrinsicName("dmod") == "mod");
   TEST(table.GetGenericIntrinsicName("dnint") == "anint");
   TEST(table.GetGenericIntrinsicName("dsign") == "sign");
   TEST(table.GetGenericIntrinsicName("dsin") == "sin");
   TEST(table.GetGenericIntrinsicName("dsinh") == "sinh");
   TEST(table.GetGenericIntrinsicName("dsqrt") == "sqrt");
   TEST(table.GetGenericIntrinsicName("dtan") == "tan");
   TEST(table.GetGenericIntrinsicName("dtanh") == "tanh");
   TEST(table.GetGenericIntrinsicName("iabs") == "abs");
   TEST(table.GetGenericIntrinsicName("idim") == "dim");
   TEST(table.GetGenericIntrinsicName("idnint") == "nint");
   TEST(table.GetGenericIntrinsicName("isign") == "sign");
   // Test a case where specific and generic name are the same.
   TEST(table.GetGenericIntrinsicName("acos") == "acos");
 }
 } // namespace Fortran::evaluate
 
 int main() {
   Fortran::evaluate::TestIntrinsics();
   return testing::Complete();
 }
diff --git a/flang/unittests/Runtime/external-io.cpp b/flang/unittests/Runtime/external-io.cpp
index 6806ce94ae1e..c307f1ce9e0c 100644
--- a/flang/unittests/Runtime/external-io.cpp
+++ b/flang/unittests/Runtime/external-io.cpp
@@ -1,469 +1,469 @@
 // Sanity test for all external I/O modes
 
 #include "testing.h"
 #include "../../runtime/io-api.h"
 #include "../../runtime/main.h"
 #include "../../runtime/stop.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstring>
 
 using namespace Fortran::runtime::io;
 
 void TestDirectUnformatted() {
   llvm::errs() << "begin TestDirectUnformatted()\n";
   // OPEN(NEWUNIT=unit,ACCESS='DIRECT',ACTION='READWRITE',&
   //   FORM='UNFORMATTED',RECL=8,STATUS='SCRATCH')
   auto io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
   IONAME(SetAccess)(io, "DIRECT", 6) || (Fail() << "SetAccess(DIRECT)", 0);
   IONAME(SetAction)
   (io, "READWRITE", 9) || (Fail() << "SetAction(READWRITE)", 0);
   IONAME(SetForm)
   (io, "UNFORMATTED", 11) || (Fail() << "SetForm(UNFORMATTED)", 0);
   std::int64_t buffer;
   static constexpr std::size_t recl{sizeof buffer};
   IONAME(SetRecl)(io, recl) || (Fail() << "SetRecl()", 0);
   IONAME(SetStatus)(io, "SCRATCH", 7) || (Fail() << "SetStatus(SCRATCH)", 0);
   int unit{-1};
   IONAME(GetNewUnit)(io, unit) || (Fail() << "GetNewUnit()", 0);
   llvm::errs() << "unit=" << unit << '\n';
   IONAME(EndIoStatement)
   (io) == IostatOk || (Fail() << "EndIoStatement() for OpenNewUnit", 0);
   static constexpr int records{10};
   for (int j{1}; j <= records; ++j) {
     // WRITE(UNIT=unit,REC=j) j
     io = IONAME(BeginUnformattedOutput)(unit, __FILE__, __LINE__);
     IONAME(SetRec)(io, j) || (Fail() << "SetRec(" << j << ')', 0);
     buffer = j;
     IONAME(OutputUnformattedBlock)
     (io, reinterpret_cast<const char *>(&buffer), recl, recl) ||
         (Fail() << "OutputUnformattedBlock()", 0);
     IONAME(EndIoStatement)
     (io) == IostatOk ||
         (Fail() << "EndIoStatement() for OutputUnformattedBlock", 0);
   }
   for (int j{records}; j >= 1; --j) {
     // READ(UNIT=unit,REC=j) n
     io = IONAME(BeginUnformattedInput)(unit, __FILE__, __LINE__);
     IONAME(SetRec)
     (io, j) || (Fail() << "SetRec(" << j << ')', 0);
     IONAME(InputUnformattedBlock)
     (io, reinterpret_cast<char *>(&buffer), recl, recl) ||
         (Fail() << "InputUnformattedBlock()", 0);
     IONAME(EndIoStatement)
     (io) == IostatOk ||
         (Fail() << "EndIoStatement() for InputUnformattedBlock", 0);
     if (buffer != j) {
       Fail() << "Read back " << buffer << " from direct unformatted record "
              << j << ", expected " << j << '\n';
     }
   }
   // CLOSE(UNIT=unit,STATUS='DELETE')
   io = IONAME(BeginClose)(unit, __FILE__, __LINE__);
   IONAME(SetStatus)(io, "DELETE", 6) || (Fail() << "SetStatus(DELETE)", 0);
   IONAME(EndIoStatement)
   (io) == IostatOk || (Fail() << "EndIoStatement() for Close", 0);
   llvm::errs() << "end TestDirectUnformatted()\n";
 }
 
 void TestDirectUnformattedSwapped() {
   llvm::errs() << "begin TestDirectUnformattedSwapped()\n";
   // OPEN(NEWUNIT=unit,ACCESS='DIRECT',ACTION='READWRITE',&
   //   FORM='UNFORMATTED',RECL=8,STATUS='SCRATCH',CONVERT='NATIVE')
   auto io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
   IONAME(SetAccess)(io, "DIRECT", 6) || (Fail() << "SetAccess(DIRECT)", 0);
   IONAME(SetAction)
   (io, "READWRITE", 9) || (Fail() << "SetAction(READWRITE)", 0);
   IONAME(SetForm)
   (io, "UNFORMATTED", 11) || (Fail() << "SetForm(UNFORMATTED)", 0);
   IONAME(SetConvert)
   (io, "NATIVE", 6) || (Fail() << "SetConvert(NATIVE)", 0);
   std::int64_t buffer;
   static constexpr std::size_t recl{sizeof buffer};
   IONAME(SetRecl)(io, recl) || (Fail() << "SetRecl()", 0);
   IONAME(SetStatus)(io, "SCRATCH", 7) || (Fail() << "SetStatus(SCRATCH)", 0);
   int unit{-1};
   IONAME(GetNewUnit)(io, unit) || (Fail() << "GetNewUnit()", 0);
   llvm::errs() << "unit=" << unit << '\n';
   IONAME(EndIoStatement)
   (io) == IostatOk || (Fail() << "EndIoStatement() for OpenNewUnit", 0);
   static constexpr int records{10};
   for (int j{1}; j <= records; ++j) {
     // WRITE(UNIT=unit,REC=j) j
     io = IONAME(BeginUnformattedOutput)(unit, __FILE__, __LINE__);
     IONAME(SetRec)(io, j) || (Fail() << "SetRec(" << j << ')', 0);
     buffer = j;
     IONAME(OutputUnformattedBlock)
     (io, reinterpret_cast<const char *>(&buffer), recl, recl) ||
         (Fail() << "OutputUnformattedBlock()", 0);
     IONAME(EndIoStatement)
     (io) == IostatOk ||
         (Fail() << "EndIoStatement() for OutputUnformattedBlock", 0);
   }
   // OPEN(UNIT=unit,STATUS='OLD',CONVERT='SWAP')
   io = IONAME(BeginOpenUnit)(unit, __FILE__, __LINE__);
   IONAME(SetStatus)(io, "OLD", 3) || (Fail() << "SetStatus(OLD)", 0);
   IONAME(SetConvert)
   (io, "SWAP", 4) || (Fail() << "SetConvert(SWAP)", 0);
   IONAME(EndIoStatement)
   (io) == IostatOk || (Fail() << "EndIoStatement() for OpenUnit", 0);
   for (int j{records}; j >= 1; --j) {
     // READ(UNIT=unit,REC=j) n
     io = IONAME(BeginUnformattedInput)(unit, __FILE__, __LINE__);
     IONAME(SetRec)
     (io, j) || (Fail() << "SetRec(" << j << ')', 0);
     IONAME(InputUnformattedBlock)
     (io, reinterpret_cast<char *>(&buffer), recl, recl) ||
         (Fail() << "InputUnformattedBlock()", 0);
     IONAME(EndIoStatement)
     (io) == IostatOk ||
         (Fail() << "EndIoStatement() for InputUnformattedBlock", 0);
     if (buffer >> 56 != j) {
       Fail() << "Read back " << (buffer >> 56)
              << " from direct unformatted record " << j << ", expected " << j
              << '\n';
     }
   }
   // CLOSE(UNIT=unit,STATUS='DELETE')
   io = IONAME(BeginClose)(unit, __FILE__, __LINE__);
   IONAME(SetStatus)(io, "DELETE", 6) || (Fail() << "SetStatus(DELETE)", 0);
   IONAME(EndIoStatement)
   (io) == IostatOk || (Fail() << "EndIoStatement() for Close", 0);
   llvm::errs() << "end TestDirectUnformatted()\n";
 }
 
 void TestSequentialFixedUnformatted() {
   llvm::errs() << "begin TestSequentialFixedUnformatted()\n";
   // OPEN(NEWUNIT=unit,ACCESS='SEQUENTIAL',ACTION='READWRITE',&
   //   FORM='UNFORMATTED',RECL=8,STATUS='SCRATCH')
   auto io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
   IONAME(SetAccess)
-      (io, "SEQUENTIAL", 10) || (Fail() << "SetAccess(SEQUENTIAL)", 0);
+  (io, "SEQUENTIAL", 10) || (Fail() << "SetAccess(SEQUENTIAL)", 0);
   IONAME(SetAction)
   (io, "READWRITE", 9) || (Fail() << "SetAction(READWRITE)", 0);
   IONAME(SetForm)
   (io, "UNFORMATTED", 11) || (Fail() << "SetForm(UNFORMATTED)", 0);
   std::int64_t buffer;
   static constexpr std::size_t recl{sizeof buffer};
   IONAME(SetRecl)(io, recl) || (Fail() << "SetRecl()", 0);
   IONAME(SetStatus)(io, "SCRATCH", 7) || (Fail() << "SetStatus(SCRATCH)", 0);
   int unit{-1};
   IONAME(GetNewUnit)(io, unit) || (Fail() << "GetNewUnit()", 0);
   llvm::errs() << "unit=" << unit << '\n';
   IONAME(EndIoStatement)
   (io) == IostatOk || (Fail() << "EndIoStatement() for OpenNewUnit", 0);
   static const int records{10};
   for (int j{1}; j <= records; ++j) {
     // DO J=1,RECORDS; WRITE(UNIT=unit) j; END DO
     io = IONAME(BeginUnformattedOutput)(unit, __FILE__, __LINE__);
     buffer = j;
     IONAME(OutputUnformattedBlock)
     (io, reinterpret_cast<const char *>(&buffer), recl, recl) ||
         (Fail() << "OutputUnformattedBlock()", 0);
     IONAME(EndIoStatement)
     (io) == IostatOk ||
         (Fail() << "EndIoStatement() for OutputUnformattedBlock", 0);
   }
   // REWIND(UNIT=unit)
   io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
   IONAME(EndIoStatement)
   (io) == IostatOk || (Fail() << "EndIoStatement() for Rewind", 0);
   for (int j{1}; j <= records; ++j) {
     // DO J=1,RECORDS; READ(UNIT=unit) n; check n; END DO
     io = IONAME(BeginUnformattedInput)(unit, __FILE__, __LINE__);
     IONAME(InputUnformattedBlock)
     (io, reinterpret_cast<char *>(&buffer), recl, recl) ||
         (Fail() << "InputUnformattedBlock()", 0);
     IONAME(EndIoStatement)
     (io) == IostatOk ||
         (Fail() << "EndIoStatement() for InputUnformattedBlock", 0);
     if (buffer != j) {
       Fail() << "Read back " << buffer
              << " from sequential fixed unformatted record " << j
              << ", expected " << j << '\n';
     }
   }
   for (int j{records}; j >= 1; --j) {
     // BACKSPACE(UNIT=unit)
     io = IONAME(BeginBackspace)(unit, __FILE__, __LINE__);
     IONAME(EndIoStatement)
     (io) == IostatOk ||
         (Fail() << "EndIoStatement() for Backspace (before read)", 0);
     // READ(UNIT=unit) n
     io = IONAME(BeginUnformattedInput)(unit, __FILE__, __LINE__);
     IONAME(InputUnformattedBlock)
     (io, reinterpret_cast<char *>(&buffer), recl, recl) ||
         (Fail() << "InputUnformattedBlock()", 0);
     IONAME(EndIoStatement)
     (io) == IostatOk ||
         (Fail() << "EndIoStatement() for InputUnformattedBlock", 0);
     if (buffer != j) {
       Fail() << "Read back " << buffer
              << " from sequential fixed unformatted record " << j
              << " after backspacing, expected " << j << '\n';
     }
     // BACKSPACE(UNIT=unit)
     io = IONAME(BeginBackspace)(unit, __FILE__, __LINE__);
     IONAME(EndIoStatement)
     (io) == IostatOk ||
         (Fail() << "EndIoStatement() for Backspace (after read)", 0);
   }
   // CLOSE(UNIT=unit,STATUS='DELETE')
   io = IONAME(BeginClose)(unit, __FILE__, __LINE__);
   IONAME(SetStatus)(io, "DELETE", 6) || (Fail() << "SetStatus(DELETE)", 0);
   IONAME(EndIoStatement)
   (io) == IostatOk || (Fail() << "EndIoStatement() for Close", 0);
   llvm::errs() << "end TestSequentialFixedUnformatted()\n";
 }
 
 void TestSequentialVariableUnformatted() {
   llvm::errs() << "begin TestSequentialVariableUnformatted()\n";
   // OPEN(NEWUNIT=unit,ACCESS='SEQUENTIAL',ACTION='READWRITE',&
   //   FORM='UNFORMATTED',STATUS='SCRATCH')
   auto io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
   IONAME(SetAccess)
   (io, "SEQUENTIAL", 10) || (Fail() << "SetAccess(SEQUENTIAL)", 0);
   IONAME(SetAction)
   (io, "READWRITE", 9) || (Fail() << "SetAction(READWRITE)", 0);
   IONAME(SetForm)
   (io, "UNFORMATTED", 11) || (Fail() << "SetForm(UNFORMATTED)", 0);
   IONAME(SetStatus)(io, "SCRATCH", 7) || (Fail() << "SetStatus(SCRATCH)", 0);
   int unit{-1};
   IONAME(GetNewUnit)(io, unit) || (Fail() << "GetNewUnit()", 0);
   llvm::errs() << "unit=" << unit << '\n';
   IONAME(EndIoStatement)
   (io) == IostatOk || (Fail() << "EndIoStatement() for OpenNewUnit", 0);
   static const int records{10};
   std::int64_t buffer[records]; // INTEGER*8 :: BUFFER(0:9) = [(j,j=0,9)]
   for (int j{0}; j < records; ++j) {
     buffer[j] = j;
   }
   for (int j{1}; j <= records; ++j) {
     // DO J=1,RECORDS; WRITE(UNIT=unit) BUFFER(0:j); END DO
     io = IONAME(BeginUnformattedOutput)(unit, __FILE__, __LINE__);
     IONAME(OutputUnformattedBlock)
     (io, reinterpret_cast<const char *>(&buffer), j * sizeof *buffer,
         sizeof *buffer) ||
         (Fail() << "OutputUnformattedBlock()", 0);
     IONAME(EndIoStatement)
     (io) == IostatOk ||
         (Fail() << "EndIoStatement() for OutputUnformattedBlock", 0);
   }
   // REWIND(UNIT=unit)
   io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
   IONAME(EndIoStatement)
   (io) == IostatOk || (Fail() << "EndIoStatement() for Rewind", 0);
   for (int j{1}; j <= records; ++j) {
     // DO J=1,RECORDS; READ(UNIT=unit) n; check n; END DO
     io = IONAME(BeginUnformattedInput)(unit, __FILE__, __LINE__);
     IONAME(InputUnformattedBlock)
     (io, reinterpret_cast<char *>(&buffer), j * sizeof *buffer,
         sizeof *buffer) ||
         (Fail() << "InputUnformattedBlock()", 0);
     IONAME(EndIoStatement)
     (io) == IostatOk ||
         (Fail() << "EndIoStatement() for InputUnformattedBlock", 0);
     for (int k{0}; k < j; ++k) {
       if (buffer[k] != k) {
         Fail() << "Read back [" << k << "]=" << buffer[k]
                << " from direct unformatted record " << j << ", expected " << k
                << '\n';
       }
     }
   }
   for (int j{records}; j >= 1; --j) {
     // BACKSPACE(unit)
     io = IONAME(BeginBackspace)(unit, __FILE__, __LINE__);
     IONAME(EndIoStatement)
     (io) == IostatOk ||
         (Fail() << "EndIoStatement() for Backspace (before read)", 0);
     // READ(unit=unit) n; check
     io = IONAME(BeginUnformattedInput)(unit, __FILE__, __LINE__);
     IONAME(InputUnformattedBlock)
     (io, reinterpret_cast<char *>(&buffer), j * sizeof *buffer,
         sizeof *buffer) ||
         (Fail() << "InputUnformattedBlock()", 0);
     IONAME(EndIoStatement)
     (io) == IostatOk ||
         (Fail() << "EndIoStatement() for InputUnformattedBlock", 0);
     for (int k{0}; k < j; ++k) {
       if (buffer[k] != k) {
         Fail() << "Read back [" << k << "]=" << buffer[k]
                << " from sequential variable unformatted record " << j
                << ", expected " << k << '\n';
       }
     }
     // BACKSPACE(unit)
     io = IONAME(BeginBackspace)(unit, __FILE__, __LINE__);
     IONAME(EndIoStatement)
     (io) == IostatOk ||
         (Fail() << "EndIoStatement() for Backspace (after read)", 0);
   }
   // CLOSE(UNIT=unit,STATUS='DELETE')
   io = IONAME(BeginClose)(unit, __FILE__, __LINE__);
   IONAME(SetStatus)(io, "DELETE", 6) || (Fail() << "SetStatus(DELETE)", 0);
   IONAME(EndIoStatement)
   (io) == IostatOk || (Fail() << "EndIoStatement() for Close", 0);
   llvm::errs() << "end TestSequentialVariableUnformatted()\n";
 }
 
 void TestDirectFormatted() {
   llvm::errs() << "begin TestDirectFormatted()\n";
   // OPEN(NEWUNIT=unit,ACCESS='DIRECT',ACTION='READWRITE',&
   //   FORM='FORMATTED',RECL=8,STATUS='SCRATCH')
   auto io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
   IONAME(SetAccess)(io, "DIRECT", 6) || (Fail() << "SetAccess(DIRECT)", 0);
   IONAME(SetAction)
   (io, "READWRITE", 9) || (Fail() << "SetAction(READWRITE)", 0);
   IONAME(SetForm)
   (io, "FORMATTED", 9) || (Fail() << "SetForm(FORMATTED)", 0);
   static constexpr std::size_t recl{8};
   IONAME(SetRecl)(io, recl) || (Fail() << "SetRecl()", 0);
   IONAME(SetStatus)(io, "SCRATCH", 7) || (Fail() << "SetStatus(SCRATCH)", 0);
   int unit{-1};
   IONAME(GetNewUnit)(io, unit) || (Fail() << "GetNewUnit()", 0);
   llvm::errs() << "unit=" << unit << '\n';
   IONAME(EndIoStatement)
   (io) == IostatOk || (Fail() << "EndIoStatement() for OpenNewUnit", 0);
   static constexpr int records{10};
   static const char fmt[]{"(I4)"};
   for (int j{1}; j <= records; ++j) {
     // WRITE(UNIT=unit,FMT=fmt,REC=j) j
     io = IONAME(BeginExternalFormattedOutput)(
         fmt, sizeof fmt - 1, unit, __FILE__, __LINE__);
     IONAME(SetRec)(io, j) || (Fail() << "SetRec(" << j << ')', 0);
     IONAME(OutputInteger64)(io, j) || (Fail() << "OutputInteger64()", 0);
     IONAME(EndIoStatement)
     (io) == IostatOk || (Fail() << "EndIoStatement() for OutputInteger64", 0);
   }
   for (int j{records}; j >= 1; --j) {
     // READ(UNIT=unit,FMT=fmt,REC=j) n
     io = IONAME(BeginExternalFormattedInput)(
         fmt, sizeof fmt - 1, unit, __FILE__, __LINE__);
     IONAME(SetRec)(io, j) || (Fail() << "SetRec(" << j << ')', 0);
     std::int64_t buffer;
     IONAME(InputInteger)(io, buffer) || (Fail() << "InputInteger()", 0);
     IONAME(EndIoStatement)
     (io) == IostatOk || (Fail() << "EndIoStatement() for InputInteger", 0);
     if (buffer != j) {
       Fail() << "Read back " << buffer << " from direct formatted record " << j
              << ", expected " << j << '\n';
     }
   }
   // CLOSE(UNIT=unit,STATUS='DELETE')
   io = IONAME(BeginClose)(unit, __FILE__, __LINE__);
   IONAME(SetStatus)(io, "DELETE", 6) || (Fail() << "SetStatus(DELETE)", 0);
   IONAME(EndIoStatement)
   (io) == IostatOk || (Fail() << "EndIoStatement() for Close", 0);
   llvm::errs() << "end TestDirectformatted()\n";
 }
 
 void TestSequentialVariableFormatted() {
   llvm::errs() << "begin TestSequentialVariableFormatted()\n";
   // OPEN(NEWUNIT=unit,ACCESS='SEQUENTIAL',ACTION='READWRITE',&
   //   FORM='FORMATTED',STATUS='SCRATCH')
   auto io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
   IONAME(SetAccess)
   (io, "SEQUENTIAL", 10) || (Fail() << "SetAccess(SEQUENTIAL)", 0);
   IONAME(SetAction)
   (io, "READWRITE", 9) || (Fail() << "SetAction(READWRITE)", 0);
   IONAME(SetForm)
   (io, "FORMATTED", 9) || (Fail() << "SetForm(FORMATTED)", 0);
   IONAME(SetStatus)(io, "SCRATCH", 7) || (Fail() << "SetStatus(SCRATCH)", 0);
   int unit{-1};
   IONAME(GetNewUnit)(io, unit) || (Fail() << "GetNewUnit()", 0);
   llvm::errs() << "unit=" << unit << '\n';
   IONAME(EndIoStatement)
   (io) == IostatOk || (Fail() << "EndIoStatement() for OpenNewUnit", 0);
   static const int records{10};
   std::int64_t buffer[records]; // INTEGER*8 :: BUFFER(0:9) = [(j,j=0,9)]
   for (int j{0}; j < records; ++j) {
     buffer[j] = j;
   }
   char fmt[32];
   for (int j{1}; j <= records; ++j) {
     std::snprintf(fmt, sizeof fmt, "(%dI4)", j);
     // DO J=1,RECORDS; WRITE(UNIT=unit,FMT=fmt) BUFFER(0:j); END DO
     io = IONAME(BeginExternalFormattedOutput)(
         fmt, std::strlen(fmt), unit, __FILE__, __LINE__);
     for (int k{0}; k < j; ++k) {
       IONAME(OutputInteger64)
       (io, buffer[k]) || (Fail() << "OutputInteger64()", 0);
     }
     IONAME(EndIoStatement)
     (io) == IostatOk || (Fail() << "EndIoStatement() for OutputInteger64", 0);
   }
   // REWIND(UNIT=unit)
   io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
   IONAME(EndIoStatement)
   (io) == IostatOk || (Fail() << "EndIoStatement() for Rewind", 0);
   for (int j{1}; j <= records; ++j) {
     std::snprintf(fmt, sizeof fmt, "(%dI4)", j);
     // DO J=1,RECORDS; READ(UNIT=unit,FMT=fmt) n; check n; END DO
     io = IONAME(BeginExternalFormattedInput)(
         fmt, std::strlen(fmt), unit, __FILE__, __LINE__);
     std::int64_t check[records];
     for (int k{0}; k < j; ++k) {
       IONAME(InputInteger)(io, check[k]) || (Fail() << "InputInteger()", 0);
     }
     IONAME(EndIoStatement)
     (io) == IostatOk || (Fail() << "EndIoStatement() for InputInteger", 0);
     for (int k{0}; k < j; ++k) {
       if (buffer[k] != check[k]) {
         Fail() << "Read back [" << k << "]=" << check[k]
                << " from sequential variable formatted record " << j
                << ", expected " << buffer[k] << '\n';
       }
     }
   }
   for (int j{records}; j >= 1; --j) {
     // BACKSPACE(unit)
     io = IONAME(BeginBackspace)(unit, __FILE__, __LINE__);
     IONAME(EndIoStatement)
     (io) == IostatOk ||
         (Fail() << "EndIoStatement() for Backspace (before read)", 0);
     std::snprintf(fmt, sizeof fmt, "(%dI4)", j);
     // READ(UNIT=unit,FMT=fmt) n; check
     io = IONAME(BeginExternalFormattedInput)(
         fmt, std::strlen(fmt), unit, __FILE__, __LINE__);
     std::int64_t check[records];
     for (int k{0}; k < j; ++k) {
       IONAME(InputInteger)(io, check[k]) || (Fail() << "InputInteger()", 0);
     }
     IONAME(EndIoStatement)
     (io) == IostatOk || (Fail() << "EndIoStatement() for InputInteger", 0);
     for (int k{0}; k < j; ++k) {
       if (buffer[k] != check[k]) {
         Fail() << "Read back [" << k << "]=" << buffer[k]
                << " from sequential variable formatted record " << j
                << ", expected " << buffer[k] << '\n';
       }
     }
     // BACKSPACE(unit)
     io = IONAME(BeginBackspace)(unit, __FILE__, __LINE__);
     IONAME(EndIoStatement)
     (io) == IostatOk ||
         (Fail() << "EndIoStatement() for Backspace (after read)", 0);
   }
   // CLOSE(UNIT=unit,STATUS='DELETE')
   io = IONAME(BeginClose)(unit, __FILE__, __LINE__);
   IONAME(SetStatus)(io, "DELETE", 6) || (Fail() << "SetStatus(DELETE)", 0);
   IONAME(EndIoStatement)
   (io) == IostatOk || (Fail() << "EndIoStatement() for Close", 0);
   llvm::errs() << "end TestSequentialVariableFormatted()\n";
 }
 
 void TestStreamUnformatted() {
   // TODO
 }
 
 int main() {
   StartTests();
   TestDirectUnformatted();
   TestDirectUnformattedSwapped();
   TestSequentialFixedUnformatted();
   TestSequentialVariableUnformatted();
   TestDirectFormatted();
   TestSequentialVariableFormatted();
   TestStreamUnformatted();
   return EndTests();
 }