[flang] Enable optional copy construction & assignment in the parse tree

[klausler]

Summary

The parse tree's several class definitions all currently go out
of their ways to ensure that they support only move constructors
and operator= (generated automatically via =default;). This was
by intent -- during construction of the backtracking parser combinators,
I did not want to worry about any risk of accidentally creating
expensive deep copies of partial parse trees.

However, copyable parse tree classes are a prerequisite for possible
implementations of possible future features, including inlining,
outlining, F'202Y template prototyping, and parameterized modules.

This patch makes it possible to enable copy construction and copy
assignment for parse tree classes. It's still off by default.

[vzakhari]

Looks good to me. Thank you!

[klausler]

Run the code through the most recent clang-format, maybe that will get it past the CI check.

flang/include/flang/Common/indirection.h

 #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 {
+template <typename A, bool COPY = false>
+class Indirection : public std::in_place_t {
 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))} {}
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> {
+template <typename A> class Indirection<A, true> : public std::in_place_t {
 public:
   using element_type = A;
 
   Indirection() = delete;
   Indirection(A *&&p) : p_{p} {
     CHECK(p_ && "assigning null pointer to Indirection");
     p = nullptr;
   }
public:
   }
 
 private:
   A *p_{nullptr};
 };
 
 template <typename A> using CopyableIndirection = Indirection<A, true>;
 
-// A variation of std::unique_ptr<> with a reified deletion routine.
+// A variation of std::unique_ptr<> with reified deletion and
+// copying routines.
 // 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(A *p, void (*del)(A *), A *(*copy)(const A *))
+      : p_{p}, deleter_{del}, copier_{copy} {}
   ForwardOwningPointer(ForwardOwningPointer &&that)
-      : p_{that.p_}, deleter_{that.deleter_} {
+      : p_{that.p_}, deleter_{that.deleter_}, copier_{that.copier_} {
     that.p_ = nullptr;
   }
   ForwardOwningPointer &operator=(ForwardOwningPointer &&that) {
-    p_ = that.p_;
+    Reset(that.p_, that.deleter_, that.copier_);
     that.p_ = nullptr;
-    deleter_ = that.deleter_;
+    return *this;
+  }
+  ForwardOwningPointer(const ForwardOwningPointer &that)
+      : p_{that.copier_(that.p_)}, deleter_{that.deleter_},
+        copier_{that.copier_} {}
+  ForwardOwningPointer &operator=(const ForwardOwningPointer &that) {
+    Reset(that.copier_(that.p_), that.deleter_, that.copier_);
     return *this;
   }
   ~ForwardOwningPointer() {
     if (p_) {
       deleter_(p_);
     }
   }
 
public:
   }
 
   void Reset(A *p = nullptr) {
     if (p_) {
       deleter_(p_);
     }
     p_ = p;
   }
-  void Reset(A *p, void (*del)(A *)) {
+  void Reset(A *p, void (*del)(A *), A *(*copy)(A *)) {
     Reset(p);
     deleter_ = del;
+    copier_ = copy;
   }
 
 private:
   A *p_{nullptr};
   void (*deleter_)(A *){nullptr};
+  A *(*copier_)(A *){nullptr};
 };
 } // namespace Fortran::common
 #endif // FORTRAN_COMMON_INDIRECTION_H_

flang/include/flang/Evaluate/call.h

 public:
   CLASS_BOILERPLATE(ProcedureRef)
   ProcedureRef(ProcedureDesignator &&p, ActualArguments &&a,
       bool hasAlternateReturns = false)
       : proc_{std::move(p)}, arguments_{std::move(a)},
         hasAlternateReturns_{hasAlternateReturns} {}
   ~ProcedureRef();
   static void Deleter(ProcedureRef *);
+  static ProcedureRef *Copier(ProcedureRef *);
 
   ProcedureDesignator &proc() { return proc_; }
   const ProcedureDesignator &proc() const { return proc_; }
   ActualArguments &arguments() { return arguments_; }
   const ActualArguments &arguments() const { return arguments_; }
   // CALL subr <<< kernel launch >>> (...); not function
   Chevrons &chevrons() { return chevrons_; }
   const Chevrons &chevrons() const { return chevrons_; }

flang/include/flang/Evaluate/expression.h

 // 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 *);
+  static GenericExprWrapper *Copier(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)} {}
   explicit GenericAssignmentWrapper(std::optional<Assignment> &&x)
       : v{std::move(x)} {}
   ~GenericAssignmentWrapper();
   static void Deleter(GenericAssignmentWrapper *);
+  static GenericAssignmentWrapper *Copier(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, )
 

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

 }
 
 /// Template helper to remove Fortran::common::Indirection wrappers.
 template <typename A>
 const A &removeIndirection(const A &a) {
   return a;
 }
 template <typename A>
-const A &removeIndirection(const Fortran::common::Indirection<A> &a) {
+const A &removeIndirection(const Fortran::common::Indirection<A, false> &a) {
+  return a.value();
+}
+template <typename A>
+const A &removeIndirection(const Fortran::common::Indirection<A, true> &a) {
   return a.value();
 }
 
 /// Clone subexpression and wrap it as a generic `Fortran::evaluate::Expr`.
 template <typename A>
 static Fortran::lower::SomeExpr toEvExpr(const A &x) {
   return Fortran::evaluate::AsGenericExpr(Fortran::common::Clone(x));
 }

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

#undef NODE_NAME
   bool Pre(const CharBlock &) { return true; }
   void Post(const CharBlock &) {}
 
   template <typename T> bool Pre(const Statement<T> &) { return true; }
   template <typename T> void Post(const Statement<T> &) {}
   template <typename T> bool Pre(const UnlabeledStatement<T> &) { return true; }
   template <typename T> void Post(const UnlabeledStatement<T> &) {}
 
-  template <typename T> bool Pre(const common::Indirection<T> &) {
-    return true;
-  }
-  template <typename T> void Post(const common::Indirection<T> &) {}
+  template <typename T> bool Pre(const Indirection<T> &) { return true; }
+  template <typename T> void Post(const Indirection<T> &) {}
 
   template <typename A> bool Pre(const Scalar<A> &) {
     Prefix("Scalar");
     return true;
   }
   template <typename A> void Post(const Scalar<A> &) { EndLineIfNonempty(); }
 
   template <typename A> bool Pre(const Constant<A> &) {

flang/include/flang/Parser/format-specification.h

 // R1309 m -> digit-string
 // R1310 d -> digit-string
 // R1311 e -> digit-string
 struct IntrinsicTypeDataEditDesc {
   enum class Kind { I, B, O, Z, F, E, EN, ES, EX, G, L, A, D };
   IntrinsicTypeDataEditDesc() = delete;
   IntrinsicTypeDataEditDesc(IntrinsicTypeDataEditDesc &&) = default;
   IntrinsicTypeDataEditDesc &operator=(IntrinsicTypeDataEditDesc &&) = default;
+#ifdef ENABLE_PARSE_TREE_COPYING
+  IntrinsicTypeDataEditDesc(const IntrinsicTypeDataEditDesc &) = default;
+  IntrinsicTypeDataEditDesc &operator=(
+      const IntrinsicTypeDataEditDesc &) = default;
+#endif
   IntrinsicTypeDataEditDesc(Kind &&k, std::optional<int> &&w,
       std::optional<int> &&d, std::optional<int> &&e)
-      : kind{k}, width{std::move(w)}, digits{std::move(d)}, exponentWidth{
-                                                                std::move(e)} {}
+      : kind{k}, width{std::move(w)}, digits{std::move(d)},
+        exponentWidth{std::move(e)} {}
   Kind kind;
   std::optional<int> width; // w
   std::optional<int> digits; // m or d
   std::optional<int> exponentWidth; // e
 };
 
 // R1307 data-edit-desc (part 2 of 2) ->
 //         DT [char-literal-constant] [( v-list )]
 // R1312 v -> [sign] digit-string
 struct DerivedTypeDataEditDesc {
   DerivedTypeDataEditDesc() = delete;
   DerivedTypeDataEditDesc(DerivedTypeDataEditDesc &&) = default;
   DerivedTypeDataEditDesc &operator=(DerivedTypeDataEditDesc &&) = default;
+#ifdef ENABLE_PARSE_TREE_COPYING
+  DerivedTypeDataEditDesc(const DerivedTypeDataEditDesc &) = default;
+  DerivedTypeDataEditDesc &operator=(const DerivedTypeDataEditDesc &) = default;
+#endif
   DerivedTypeDataEditDesc(std::string &&t, std::list<std::int64_t> &&p)
       : type{std::move(t)}, parameters{std::move(p)} {}
   std::string type;
   std::list<std::int64_t> parameters;
 };
 
 // R1313 control-edit-desc ->
 //         position-edit-desc | [r] / | : | sign-edit-desc | k P |
enum class Kind {
     DC,
     DP,
     Dollar, // extension: inhibit newline on output
     Backslash, // ditto, but only on terminals
   };
   ControlEditDesc() = delete;
   ControlEditDesc(ControlEditDesc &&) = default;
   ControlEditDesc &operator=(ControlEditDesc &&) = default;
+#ifdef ENABLE_PARSE_TREE_COPYING
+  ControlEditDesc(const ControlEditDesc &) = default;
+  ControlEditDesc &operator=(const ControlEditDesc &) = default;
+#endif
   explicit ControlEditDesc(Kind k) : kind{k} {}
   ControlEditDesc(Kind k, std::int64_t ct) : kind{k}, count{ct} {}
   ControlEditDesc(std::int64_t ct, Kind k) : kind{k}, count{ct} {}
   Kind kind;
   std::int64_t count{1}; // r, k, or n
 };
 
 // R1304 format-item ->
 //         [r] data-edit-desc | control-edit-desc | char-string-edit-desc |
 //         [r] ( format-items )
 // R1306 r -> digit-string
 // R1321 char-string-edit-desc
 struct FormatItem {
   FormatItem() = delete;
   FormatItem(FormatItem &&) = default;
   FormatItem &operator=(FormatItem &&) = default;
+#ifdef ENABLE_PARSE_TREE_COPYING
+  FormatItem(const FormatItem &) = default;
+  FormatItem &operator=(const FormatItem &) = default;
+#endif
   template <typename A, typename = common::NoLvalue<A>>
   FormatItem(std::optional<std::uint64_t> &&r, A &&x)
       : repeatCount{std::move(r)}, u{std::move(x)} {}
   template <typename A, typename = common::NoLvalue<A>>
   explicit FormatItem(A &&x) : u{std::move(x)} {}
   std::optional<std::uint64_t> repeatCount;
   std::variant<IntrinsicTypeDataEditDesc, DerivedTypeDataEditDesc,
       ControlEditDesc, std::string, std::list<FormatItem>>
       u;
 };
 
 // R1302 format-specification ->
 //         ( [format-items] ) | ( [format-items ,] unlimited-format-item )
 // R1303 format-items -> format-item [[,] format-item]...
 // R1305 unlimited-format-item -> * ( format-items )
 struct FormatSpecification {
   FormatSpecification() = delete;
   FormatSpecification(FormatSpecification &&) = default;
   FormatSpecification &operator=(FormatSpecification &&) = default;
+#ifdef ENABLE_PARSE_TREE_COPYING
+  FormatSpecification(const FormatSpecification &) = default;
+  FormatSpecification &operator=(const FormatSpecification &) = default;
+#endif
   explicit FormatSpecification(std::list<FormatItem> &&is)
       : items(std::move(is)) {}
   FormatSpecification(std::list<FormatItem> &&is, std::list<FormatItem> &&us)
       : items(std::move(is)), unlimitedItems(std::move(us)) {}
   std::list<FormatItem> items, unlimitedItems;
 };
 } // namespace Fortran::format
 #endif // FORTRAN_PARSER_FORMAT_SPECIFICATION_H_

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

 std::enable_if_t<ConstraintTrait<A>> Walk(A &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.thing, mutator);
     mutator.Post(x);
   }
 }
 
 template <typename T, typename V>
-void Walk(const common::Indirection<T> &x, V &visitor) {
+void Walk(const Indirection<T> &x, V &visitor) {
   Walk(x.value(), visitor);
 }
-template <typename T, typename M>
-void Walk(common::Indirection<T> &x, M &mutator) {
+template <typename T, typename M> void Walk(Indirection<T> &x, M &mutator) {
   Walk(x.value(), mutator);
 }
 
 template <typename T, typename V> void Walk(const Statement<T> &x, V &visitor) {
   if (visitor.Pre(x)) {
     // N.B. The label, if any, is not visited.
     Walk(x.source, visitor);
     Walk(x.statement, visitor);

flang/include/flang/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).
 
+// Parse tree node class types do not, by default, have copy constructors
+// or copy assignment operators.  They are explicitly declared "= delete;
+// to make this clear, although a C++ compiler shouldn't default them anyway
+// due to the presence of explicitly defaulted move constructors and move
+// assignments.  This default behavior ensures that the parser is always
+// correctly using fast move semantics and can't be mysteriously slowed
+// down by an unintentional deep copy.
+
+// Include this header with ENABLE_PARSE_TREE_COPYING defined in order
+// to enable copy constructors and copy assignment operators.
+
 #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 <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 or function ref
 } // namespace Fortran::evaluate
 
+namespace Fortran::parser {
+
 // 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=.
+#ifdef ENABLE_PARSE_TREE_COPYING
+static constexpr bool isCopyingEnabled{true};
 #define COPY_AND_ASSIGN_BOILERPLATE(classname) \
   classname(classname &&) = default; \
+  classname(const classname &) = default; \
   classname &operator=(classname &&) = default; \
+  classname &operator=(const classname &) = default
+#else
+static constexpr bool isCopyingEnabled{false};
+#define COPY_AND_ASSIGN_BOILERPLATE(classname) \
+  classname(classname &&) = default; \
   classname(const classname &) = delete; \
+  classname &operator=(classname &&) = default; \
   classname &operator=(const classname &) = delete
+#endif
 
 // 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 WRAPPER_CLASS_BOILERPLATE(classname, type) \
   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 OpenMPConstruct;
 struct OpenMPDeclarativeConstruct;
 struct OmpEndLoopDirective;
 struct CUFKernelDoConstruct;
 
 // Cooked character stream locations
 using Location = const char *;
 
+template <typename A>
+using Indirection = common::Indirection<A, isCopyingEnabled>;
+
 // A parse tree node with provenance only
 struct Verbatim {
   // Allow a no-arg constructor for Verbatim so parsers can return `RESULT{}`.
   constexpr Verbatim() {}
   COPY_AND_ASSIGN_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;
+  BOILERPLATE(Scalar);
   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;
+  BOILERPLATE(Constant);
   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;
+  BOILERPLATE(Integer);
   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;
+  BOILERPLATE(Logical);
   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;
+  BOILERPLATE(DefaultChar);
   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 LogicalExpr = Logical<Indirection<Expr>>; // R1024
+using DefaultCharExpr = DefaultChar<Indirection<Expr>>; // R1025
+using IntExpr = Integer<Indirection<Expr>>; // R1026
+using ConstantExpr = Constant<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 = common::Label; // 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)) {}
+  UnlabeledStatement(A &&s) : statement(std::move(s)) {}
+  COPY_AND_ASSIGN_BOILERPLATE(UnlabeledStatement);
   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)) {}
+  COPY_AND_ASSIGN_BOILERPLATE(Statement);
   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
 // Extension: CUDA data attribute 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>,
-      common::Indirection<CUDAAttributesStmt>>
+  std::variant<Indirection<AccessStmt>, Indirection<AllocatableStmt>,
+      Indirection<AsynchronousStmt>, Indirection<BindStmt>,
+      Indirection<CodimensionStmt>, Indirection<ContiguousStmt>,
+      Indirection<DimensionStmt>, Indirection<ExternalStmt>,
+      Indirection<IntentStmt>, Indirection<IntrinsicStmt>,
+      Indirection<NamelistStmt>, Indirection<OptionalStmt>,
+      Indirection<PointerStmt>, Indirection<ProtectedStmt>,
+      Indirection<SaveStmt>, Indirection<TargetStmt>, Indirection<ValueStmt>,
+      Indirection<VolatileStmt>, Indirection<CommonStmt>,
+      Indirection<EquivalenceStmt>, Indirection<BasedPointerStmt>,
+      Indirection<CUDAAttributesStmt>>
       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>>,
+  std::variant<Indirection<DerivedTypeDef>, Indirection<EnumDef>,
+      Statement<Indirection<GenericStmt>>, Indirection<InterfaceBlock>,
+      Statement<Indirection<ParameterStmt>>,
+      Statement<Indirection<OldParameterStmt>>,
+      Statement<Indirection<ProcedureDeclarationStmt>>,
       Statement<OtherSpecificationStmt>,
-      Statement<common::Indirection<TypeDeclarationStmt>>,
-      common::Indirection<StructureDef>,
-      common::Indirection<OpenACCDeclarativeConstruct>,
-      common::Indirection<OpenMPDeclarativeConstruct>,
-      common::Indirection<CompilerDirective>>
+      Statement<Indirection<TypeDeclarationStmt>>, Indirection<StructureDef>,
+      Indirection<OpenACCDeclarativeConstruct>,
+      Indirection<OpenMPDeclarativeConstruct>, 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>>,
-      common::Indirection<CompilerDirective>>
+  std::variant<Statement<Indirection<ImplicitStmt>>,
+      Statement<Indirection<ParameterStmt>>,
+      Statement<Indirection<OldParameterStmt>>,
+      Statement<Indirection<FormatStmt>>, Statement<Indirection<EntryStmt>>,
+      Indirection<CompilerDirective>>
       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>
+  std::variant<SpecificationConstruct, Statement<Indirection<DataStmt>>,
+      Statement<Indirection<FormatStmt>>, Statement<Indirection<EntryStmt>>,
+      Statement<Indirection<StmtFunctionStmt>>, ErrorRecovery>
       u;
 };
 
 // R504 specification-part -> [use-stmt]... [import-stmt]... [implicit-part]
 //                            [declaration-construct]...
 // PARAMETER, FORMAT, and ENTRY statements that appear before any other
 // kind of declaration-construct will be parsed into the implicit-part,
 // even if there are no IMPLICIT statements.
 struct SpecificationPart {
   TUPLE_CLASS_BOILERPLATE(SpecificationPart);
   std::tuple<std::list<OpenACCDeclarativeConstruct>,
       std::list<OpenMPDeclarativeConstruct>,
-      std::list<common::Indirection<CompilerDirective>>,
-      std::list<Statement<common::Indirection<UseStmt>>>,
-      std::list<Statement<common::Indirection<ImportStmt>>>, ImplicitPart,
+      std::list<Indirection<CompilerDirective>>,
+      std::list<Statement<Indirection<UseStmt>>>,
+      std::list<Statement<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>>
+  std::variant<Indirection<FunctionSubprogram>,
+      Indirection<SubroutineSubprogram>>
       u;
 };
 
 // R1543 contains-stmt -> CONTAINS
 EMPTY_CLASS(ContainsStmt);
 
 // R511 internal-subprogram-part -> contains-stmt [internal-subprogram]...
 struct InternalSubprogramPart {

 //        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>>
+  std::variant<Indirection<AllocateStmt>, Indirection<AssignmentStmt>,
+      Indirection<BackspaceStmt>, Indirection<CallStmt>, Indirection<CloseStmt>,
+      ContinueStmt, Indirection<CycleStmt>, Indirection<DeallocateStmt>,
+      Indirection<EndfileStmt>, Indirection<EventPostStmt>,
+      Indirection<EventWaitStmt>, Indirection<ExitStmt>, FailImageStmt,
+      Indirection<FlushStmt>, Indirection<FormTeamStmt>, Indirection<GotoStmt>,
+      Indirection<IfStmt>, Indirection<InquireStmt>, Indirection<LockStmt>,
+      Indirection<NullifyStmt>, Indirection<OpenStmt>,
+      Indirection<PointerAssignmentStmt>, Indirection<PrintStmt>,
+      Indirection<ReadStmt>, Indirection<ReturnStmt>, Indirection<RewindStmt>,
+      Indirection<StopStmt>, Indirection<SyncAllStmt>,
+      Indirection<SyncImagesStmt>, Indirection<SyncMemoryStmt>,
+      Indirection<SyncTeamStmt>, Indirection<UnlockStmt>, Indirection<WaitStmt>,
+      Indirection<WhereStmt>, Indirection<WriteStmt>,
+      Indirection<ComputedGotoStmt>, Indirection<ForallStmt>,
+      Indirection<ArithmeticIfStmt>, Indirection<AssignStmt>,
+      Indirection<AssignedGotoStmt>, 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 |
 // (CUDA) CUF-kernel-do-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<AccEndCombinedDirective>,
-      common::Indirection<OpenMPConstruct>,
-      common::Indirection<OmpEndLoopDirective>,
-      common::Indirection<CUFKernelDoConstruct>>
+  std::variant<Statement<ActionStmt>, Indirection<AssociateConstruct>,
+      Indirection<BlockConstruct>, Indirection<CaseConstruct>,
+      Indirection<ChangeTeamConstruct>, Indirection<CriticalConstruct>,
+      Statement<Indirection<LabelDoStmt>>, Statement<Indirection<EndDoStmt>>,
+      Indirection<DoConstruct>, Indirection<IfConstruct>,
+      Indirection<SelectRankConstruct>, Indirection<SelectTypeConstruct>,
+      Indirection<WhereConstruct>, Indirection<ForallConstruct>,
+      Indirection<CompilerDirective>, Indirection<OpenACCConstruct>,
+      Indirection<AccEndCombinedDirective>, Indirection<OpenMPConstruct>,
+      Indirection<OmpEndLoopDirective>, Indirection<CUFKernelDoConstruct>>
       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>
+  std::variant<ExecutableConstruct, Statement<Indirection<FormatStmt>>,
+      Statement<Indirection<EntryStmt>>, Statement<Indirection<DataStmt>>,
+      Statement<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>,
-      common::Indirection<CompilerDirective>>
+  std::variant<Indirection<MainProgram>, Indirection<FunctionSubprogram>,
+      Indirection<SubroutineSubprogram>, Indirection<Module>,
+      Indirection<Submodule>, Indirection<BlockData>,
+      Indirection<CompilerDirective>>
       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 ComponentAttrSpec {
   UNION_CLASS_BOILERPLATE(ComponentAttrSpec);
   std::variant<AccessSpec, Allocatable, CoarraySpec, Contiguous,
       ComponentArraySpec, Pointer, common::CUDADataAttr, ErrorRecovery>
       u;
 };
 
 // R806 null-init -> function-reference   ... which must be NULL()
-WRAPPER_CLASS(NullInit, common::Indirection<Expr>);
+WRAPPER_CLASS(NullInit, Indirection<Expr>);
 
 // R744 initial-data-target -> designator
-using InitialDataTarget = common::Indirection<Designator>;
+using InitialDataTarget = 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>>>
+      std::list<Indirection<DataStmtValue>>>
       u;
 };
 
 // R739 component-decl ->
 //        component-name [( component-array-spec )]
 //        [lbracket coarray-spec rbracket] [* char-length]
 //        [component-initialization]
 struct ComponentDecl {
struct TypeBoundProcedureStmt {
   };
   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::tuple<std::optional<AccessSpec>, 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 ->
std::tuple<Statement<DerivedTypeStmt>, std::list<Statement<TypeParamDefStmt>>,
       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>);
+WRAPPER_CLASS(ComponentDataSource, 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] )

 
 // 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;
+  std::variant<Triplet, Indirection<Expr>, 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;
+  BOILERPLATE(LoopBounds);
   VAR name;
   BOUND lower, upper;
   std::optional<BOUND> step;
 };
 
 using ScalarName = Scalar<Name>;
-using ScalarExpr = Scalar<common::Indirection<Expr>>;
+using ScalarExpr = Scalar<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>;

 //        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
 // "access-name" is ambiguous with "generic-spec", so that's what's parsed
-WRAPPER_CLASS(AccessId, common::Indirection<GenericSpec>);
+WRAPPER_CLASS(AccessId, Indirection<GenericSpec>);
 
 // R827 access-stmt -> access-spec [[::] access-id-list]
 struct AccessStmt {
   TUPLE_CLASS_BOILERPLATE(AccessStmt);
   std::tuple<AccessSpec, std::list<AccessId>> t;
 };
 
 // R830 allocatable-decl ->

 // 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>>;
+using ConstantSubobject = Constant<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 |
 //        structure-constructor
 // N.B. Parsing ambiguities abound here without recourse to symbols
 // (see comments on R845's parser).
 struct DataStmtConstant {
   UNION_CLASS_BOILERPLATE(DataStmtConstant);
   CharBlock source;
   mutable TypedExpr typedExpr;
   std::variant<LiteralConstant, SignedIntLiteralConstant,
       SignedRealLiteralConstant, SignedComplexLiteralConstant, NullInit,
-      common::Indirection<Designator>, StructureConstructor>
+      Indirection<Designator>, 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;
+  std::variant<Scalar<Indirection<Designator>>, 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;
+  std::variant<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;
 };
 
struct CommonStmt {
   };
   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>);
+WRAPPER_CLASS(EquivalenceObject, 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);
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>>);
+WRAPPER_CLASS(TeamValue, Scalar<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(Stat, Scalar<Integer<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>);
+  WRAPPER_CLASS(IntrinsicUnary, 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
+  WRAPPER_CLASS(PercentLoc, Indirection<Variable>); // %LOC(v) extension
 
   struct DefinedUnary {
     TUPLE_CLASS_BOILERPLATE(DefinedUnary);
-    std::tuple<DefinedOpName, common::Indirection<Expr>> t;
+    std::tuple<DefinedOpName, Indirection<Expr>> t;
   };
 
   struct IntrinsicBinary {
     TUPLE_CLASS_BOILERPLATE(IntrinsicBinary);
-    std::tuple<common::Indirection<Expr>, common::Indirection<Expr>> t;
+    std::tuple<Indirection<Expr>, Indirection<Expr>> t;
   };
   struct Power : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct Multiply : public IntrinsicBinary {
     using IntrinsicBinary::IntrinsicBinary;
   };
   struct Divide : public IntrinsicBinary {
struct Expr {
 
   // 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;
+    std::tuple<DefinedOpName, Indirection<Expr>, 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, common::Indirection<SubstringInquiry>>
+  std::variant<Indirection<CharLiteralConstantSubstring>, LiteralConstant,
+      Indirection<Designator>, ArrayConstructor, StructureConstructor,
+      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, Indirection<SubstringInquiry>>
       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{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>>
+  std::variant<Name, Indirection<StructureComponent>, Indirection<ArrayElement>,
+      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
struct Designator {
   std::variant<DataRef, Substring> u;
 };
 
 // R902 variable -> designator | function-reference
 struct Variable {
   UNION_CLASS_BOILERPLATE(Variable);
   mutable TypedExpr typedExpr;
   CharBlock GetSource() const;
-  std::variant<common::Indirection<Designator>,
-      common::Indirection<FunctionReference>>
-      u;
+  std::variant<Indirection<Designator>, 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.

 // R928 alloc-opt ->
 //        ERRMSG = errmsg-variable | MOLD = source-expr |
 //        SOURCE = source-expr | STAT = stat-variable |
 // (CUDA) STREAM = scalar-int-expr
 //        PINNED = scalar-logical-variable
 // R931 source-expr -> expr
 struct AllocOpt {
   UNION_CLASS_BOILERPLATE(AllocOpt);
-  WRAPPER_CLASS(Mold, common::Indirection<Expr>);
-  WRAPPER_CLASS(Source, common::Indirection<Expr>);
-  WRAPPER_CLASS(Stream, common::Indirection<ScalarIntExpr>);
-  WRAPPER_CLASS(Pinned, common::Indirection<ScalarLogicalVariable>);
+  WRAPPER_CLASS(Mold, Indirection<Expr>);
+  WRAPPER_CLASS(Source, Indirection<Expr>);
+  WRAPPER_CLASS(Stream, Indirection<ScalarIntExpr>);
+  WRAPPER_CLASS(Pinned, Indirection<ScalarLogicalVariable>);
   std::variant<Mold, Source, StatOrErrmsg, Stream, Pinned> 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>,
struct 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>>
+      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;
std::tuple<Statement<WhereConstructStmt>, std::list<WhereBodyConstruct>,
       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;
+  std::tuple<std::optional<Name>, 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>,
+  std::tuple<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>>
+      WhereConstruct, 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 IoControlSpec {
   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;
+  std::variant<Variable, 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;
+  std::variant<Expr, 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)),

 // 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>>
+  std::variant<Indirection<FunctionSubprogram>,
+      Indirection<SubroutineSubprogram>, 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;
 };
struct InterfaceStmt {
 
   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;
+  std::variant<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);

 
 // 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>,
+    std::tuple<Statement<FunctionStmt>, Indirection<SpecificationPart>,
         Statement<EndFunctionStmt>>
         t;
   };
   struct Subroutine {
     TUPLE_CLASS_BOILERPLATE(Subroutine);
-    std::tuple<Statement<SubroutineStmt>,
-        common::Indirection<SpecificationPart>, Statement<EndSubroutineStmt>>
+    std::tuple<Statement<SubroutineStmt>, 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)

 
 // 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;
+  ActualArg(Expr &&x) : u{Indirection<Expr>(std::move(x))} {}
+  std::variant<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;
 };
 

 };
 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>>
+  std::variant<Statement<DataComponentDefStmt>, Indirection<StructureDef>,
+      Indirection<Union>>
       u;
 };
 
 struct Map {
   EMPTY_CLASS(MapStmt);
   EMPTY_CLASS(EndMapStmt);
   TUPLE_CLASS_BOILERPLATE(Map);
   std::tuple<Statement<MapStmt>, std::list<StructureField>,

flang/include/flang/Parser/tools.h

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

flang/include/flang/Parser/user-state.h

 
 // Definitions of parser classes that manipulate the UserState.
 struct StartNewSubprogram {
   using resultType = Success;
   static std::optional<Success> Parse(ParseState &);
 };
 
 struct CapturedLabelDoStmt {
-  using resultType = Statement<common::Indirection<LabelDoStmt>>;
+  using resultType = Statement<Indirection<LabelDoStmt>>;
   static std::optional<resultType> Parse(ParseState &);
 };
 
 struct EndDoStmtForCapturedLabelDoStmt {
-  using resultType = Statement<common::Indirection<EndDoStmt>>;
+  using resultType = Statement<Indirection<EndDoStmt>>;
   static std::optional<resultType> Parse(ParseState &);
 };
 
 struct EnterNonlabelDoConstruct {
   using resultType = Success;
   static std::optional<Success> Parse(ParseState &);
 };
 

flang/include/flang/Semantics/expression.h

 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);
+        evaluate::GenericExprWrapper::Deleter,
+        evaluate::GenericExprWrapper::Copier);
   }
-  template <typename T> void Set(const common::Indirection<T> &x) {
+  template <typename T, bool COPY>
+  void Set(const common::Indirection<T, COPY> &x) {
     Set(x.value());
   }
   template <typename T> void Set(const T &x) {
     if constexpr (parser::HasTypedExpr<T>::value) {
       Set(x.typedExpr);
     } else if constexpr (ConstraintTrait<T>) {
       Set(x.thing);
     } else if constexpr (WrapperTrait<T>) {
public:
   MaybeExpr Analyze(const parser::Expr &);
   MaybeExpr Analyze(const parser::Variable &);
   MaybeExpr Analyze(const parser::Selector &);
   MaybeExpr Analyze(const parser::Designator &);
   MaybeExpr Analyze(const parser::DataStmtValue &);
   MaybeExpr Analyze(const parser::AllocateObject &);
   MaybeExpr Analyze(const parser::PointerObject &);
 
-  template <typename A> MaybeExpr Analyze(const common::Indirection<A> &x) {
+  template <typename A> MaybeExpr Analyze(const parser::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;
     }

flang/include/flang/Semantics/tools.h

public:
 
   // Specializations for parse tree nodes that have a typedExpr member.
   const SomeExpr *Get(const parser::Expr &);
   const SomeExpr *Get(const parser::Variable &);
   const SomeExpr *Get(const parser::DataStmtConstant &);
   const SomeExpr *Get(const parser::AllocateObject &);
   const SomeExpr *Get(const parser::PointerObject &);
 
-  template <typename T> const SomeExpr *Get(const common::Indirection<T> &x) {
+  template <typename T, bool COPY>
+  const SomeExpr *Get(const common::Indirection<T, COPY> &x) {
     return Get(x.value());
   }
   template <typename T> const SomeExpr *Get(const std::optional<T> &x) {
     return x ? Get(*x) : nullptr;
   }
   template <typename T> const SomeExpr *Get(const T &x) {
     static_assert(
         !parser::HasTypedExpr<T>::value, "explicit Get overload must be added");

 
 // The LabelEnforce class (given a set of labels) provides an error message if
 // there is a branch to a label which is not in the given set.
 class LabelEnforce {
 public:
   LabelEnforce(SemanticsContext &context, std::set<parser::Label> &&labels,
       parser::CharBlock constructSourcePosition, const char *construct)
       : context_{context}, labels_{labels},
-        constructSourcePosition_{constructSourcePosition}, construct_{
-                                                               construct} {}
+        constructSourcePosition_{constructSourcePosition},
+        construct_{construct} {}
   template <typename T> bool Pre(const T &) { return true; }
   template <typename T> bool Pre(const parser::Statement<T> &statement) {
     currentStatementSourcePosition_ = statement.source;
     return true;
   }
 
   template <typename T> void Post(const T &) {}
 

flang/lib/Evaluate/call.cpp

 }
 
 void ActualArgument::Parenthesize() {
   u_ = evaluate::Parenthesize(std::move(DEREF(UnwrapExpr())));
 }
 
 SpecificIntrinsic::SpecificIntrinsic(
     IntrinsicProcedure n, characteristics::Procedure &&chars)
-    : name{n}, characteristics{
-                   new characteristics::Procedure{std::move(chars)}} {}
+    : name{n},
+      characteristics{new characteristics::Procedure{std::move(chars)}} {}
 
 DEFINE_DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(SpecificIntrinsic)
 
 SpecificIntrinsic::~SpecificIntrinsic() {}
 
 bool SpecificIntrinsic::operator==(const SpecificIntrinsic &that) const {
   return name == that.name && characteristics == that.characteristics;
 }
int ProcedureRef::Rank() const {
   } else {
     return proc_.Rank();
   }
 }
 
 ProcedureRef::~ProcedureRef() {}
 
 void ProcedureRef::Deleter(ProcedureRef *p) { delete p; }
+ProcedureRef *ProcedureRef::Copier(ProcedureRef *p) {
+  return p ? new ProcedureRef{*p} : nullptr;
+}
 
 } // namespace Fortran::evaluate

flang/lib/Evaluate/expression.cpp

StructureConstructor &StructureConstructor::Add(
     const Symbol &symbol, Expr<SomeType> &&expr) {
   values_.emplace(symbol, std::move(expr));
   return *this;
 }
 
 GenericExprWrapper::~GenericExprWrapper() {}
 
 void GenericExprWrapper::Deleter(GenericExprWrapper *p) { delete p; }
+GenericExprWrapper *GenericExprWrapper::Copier(GenericExprWrapper *p) {
+  return p ? new GenericExprWrapper(*p) : nullptr;
+}
 
 GenericAssignmentWrapper::~GenericAssignmentWrapper() {}
 
 void GenericAssignmentWrapper::Deleter(GenericAssignmentWrapper *p) {
   delete p;
 }
+GenericAssignmentWrapper *GenericAssignmentWrapper::Copier(
+    GenericAssignmentWrapper *p) {
+  return p ? new GenericAssignmentWrapper{*p} : nullptr;
+}
 
 template <TypeCategory CAT> int Expr<SomeKind<CAT>>::GetKind() const {
   return common::visit(
       [](const auto &kx) { return std::decay_t<decltype(kx)>::Result::kind; },
       u);
 }
 
 int Expr<SomeCharacter>::GetKind() const {

flang/lib/Lower/Bridge.cpp

void cleanupExplicitSpace() {
     explicitIterSpace.leave();
     localSymbols.popScope();
   }
 
   /// Generate FIR for a FORALL statement.
   void genFIR(const Fortran::parser::ForallStmt &stmt) {
     const auto &concurrentHeader =
         std::get<
-            Fortran::common::Indirection<Fortran::parser::ConcurrentHeader>>(
+            Fortran::parser::Indirection<Fortran::parser::ConcurrentHeader>>(
             stmt.t)
             .value();
     if (lowerToHighLevelFIR()) {
       mlir::OpBuilder::InsertPoint insertPt = builder->saveInsertionPoint();
       localSymbols.pushScope();
       genForallNest(concurrentHeader);
       genFIR(std::get<Fortran::parser::UnlabeledStatement<
                  Fortran::parser::ForallAssignmentStmt>>(stmt.t)
genNestedStatement(
         std::get<
             Fortran::parser::Statement<Fortran::parser::ForallConstructStmt>>(
             forall.t));
     for (const Fortran::parser::ForallBodyConstruct &s :
          std::get<std::list<Fortran::parser::ForallBodyConstruct>>(forall.t)) {
       std::visit(
           Fortran::common::visitors{
               [&](const Fortran::parser::WhereConstruct &b) { genFIR(b); },
-              [&](const Fortran::common::Indirection<
+              [&](const Fortran::parser::Indirection<
                   Fortran::parser::ForallConstruct> &b) { genFIR(b.value()); },
               [&](const auto &b) { genNestedStatement(b); }},
           s.u);
     }
     genNestedStatement(
         std::get<Fortran::parser::Statement<Fortran::parser::EndForallStmt>>(
             forall.t));
     if (lowerToHighLevelFIR()) {
       localSymbols.popScope();
       builder->restoreInsertionPoint(insertPt);
     }
   }
 
   /// Lower the concurrent header specification.
   void genFIR(const Fortran::parser::ForallConstructStmt &stmt) {
     const auto &concurrentHeader =
         std::get<
-            Fortran::common::Indirection<Fortran::parser::ConcurrentHeader>>(
+            Fortran::parser::Indirection<Fortran::parser::ConcurrentHeader>>(
             stmt.t)
             .value();
     if (lowerToHighLevelFIR())
       genForallNest(concurrentHeader);
     else
       genFIR(concurrentHeader);
   }
 
void genFIR(const Fortran::parser::WhereBodyConstruct &body) {
     std::visit(
         Fortran::common::visitors{
             [&](const Fortran::parser::Statement<
                 Fortran::parser::AssignmentStmt> &stmt) {
               genNestedStatement(stmt);
             },
             [&](const Fortran::parser::Statement<Fortran::parser::WhereStmt>
                     &stmt) { genNestedStatement(stmt); },
-            [&](const Fortran::common::Indirection<
+            [&](const Fortran::parser::Indirection<
                 Fortran::parser::WhereConstruct> &c) { genFIR(c.value()); },
         },
         body.u);
   }
 
   /// Lower a Where or Elsewhere mask into an hlfir mask region.
   void lowerWhereMaskToHlfir(mlir::Location loc,
                              const Fortran::semantics::SomeExpr *maskExpr) {
analyzeExplicitSpace(
             ew.t)
             .statement);
     for (const Fortran::parser::WhereBodyConstruct &e :
          std::get<std::list<Fortran::parser::WhereBodyConstruct>>(ew.t))
       analyzeExplicitSpace(e);
   }
   void analyzeExplicitSpace(const Fortran::parser::WhereBodyConstruct &body) {
     std::visit(Fortran::common::visitors{
-                   [&](const Fortran::common::Indirection<
+                   [&](const Fortran::parser::Indirection<
                        Fortran::parser::WhereConstruct> &wc) {
                      analyzeExplicitSpace(wc.value());
                    },
                    [&](const auto &s) { analyzeExplicitSpace(s.statement); }},
                body.u);
   }
   void analyzeExplicitSpace(const Fortran::parser::MaskedElsewhereStmt &stmt) {
     const Fortran::lower::SomeExpr *exp = Fortran::semantics::GetExpr(
void analyzeExplicitSpace(const Fortran::parser::WhereStmt &stmt) {
     const std::optional<Fortran::evaluate::Assignment> &assign =
         std::get<Fortran::parser::AssignmentStmt>(stmt.t).typedAssignment->v;
     assert(assign.has_value() && "WHERE has no statement");
     analyzeExplicitSpace(assign.operator->());
   }
   void analyzeExplicitSpace(const Fortran::parser::ForallStmt &forall) {
     analyzeExplicitSpace(
         std::get<
-            Fortran::common::Indirection<Fortran::parser::ConcurrentHeader>>(
+            Fortran::parser::Indirection<Fortran::parser::ConcurrentHeader>>(
             forall.t)
             .value());
     analyzeExplicitSpace(std::get<Fortran::parser::UnlabeledStatement<
                              Fortran::parser::ForallAssignmentStmt>>(forall.t)
                              .statement);
     analyzeExplicitSpacePop();
   }
   void
   analyzeExplicitSpace(const Fortran::parser::ForallConstructStmt &forall) {
     analyzeExplicitSpace(
         std::get<
-            Fortran::common::Indirection<Fortran::parser::ConcurrentHeader>>(
+            Fortran::parser::Indirection<Fortran::parser::ConcurrentHeader>>(
             forall.t)
             .value());
   }
   void analyzeExplicitSpace(const Fortran::parser::ForallConstruct &forall) {
     analyzeExplicitSpace(
         std::get<
             Fortran::parser::Statement<Fortran::parser::ForallConstructStmt>>(
             forall.t)
             .statement);
     for (const Fortran::parser::ForallBodyConstruct &s :
          std::get<std::list<Fortran::parser::ForallBodyConstruct>>(forall.t)) {
       std::visit(Fortran::common::visitors{
-                     [&](const Fortran::common::Indirection<
+                     [&](const Fortran::parser::Indirection<
                          Fortran::parser::ForallConstruct> &b) {
                        analyzeExplicitSpace(b.value());
                      },
                      [&](const Fortran::parser::WhereConstruct &w) {
                        analyzeExplicitSpace(w);
                      },
                      [&](const auto &b) { analyzeExplicitSpace(b.statement); }},
                  s.u);

flang/lib/Lower/OpenMP.cpp

genOMP(Fortran::lower::AbstractConverter &converter,
   }
 }
 
 static bool checkForSingleVariableOnRHS(
     const Fortran::parser::AssignmentStmt &assignmentStmt) {
   // Check if the assignment statement has a single variable on the RHS
   const Fortran::parser::Expr &expr{
       std::get<Fortran::parser::Expr>(assignmentStmt.t)};
-  const Fortran::common::Indirection<Fortran::parser::Designator> *designator =
-      std::get_if<Fortran::common::Indirection<Fortran::parser::Designator>>(
+  const Fortran::parser::Indirection<Fortran::parser::Designator> *designator =
+      std::get_if<Fortran::parser::Indirection<Fortran::parser::Designator>>(
           &expr.u);
   const Fortran::parser::Name *name =
       designator
           ? Fortran::semantics::getDesignatorNameIfDataRef(designator->value())
           : nullptr;
   return name != nullptr;
 }
 

flang/lib/Lower/PFTBuilder.cpp

 namespace {
 /// Helpers to unveil parser node inside Fortran::parser::Statement<>,
 /// Fortran::parser::UnlabeledStatement, and Fortran::common::Indirection<>
 template <typename A>
 struct RemoveIndirectionHelper {
   using Type = A;
 };
 template <typename A>
-struct RemoveIndirectionHelper<common::Indirection<A>> {
+struct RemoveIndirectionHelper<common::Indirection<A, false>> {
+  using Type = A;
+};
+template <typename A>
+struct RemoveIndirectionHelper<common::Indirection<A, true>> {
   using Type = A;
 };
 
 template <typename A>
 struct UnwrapStmt {
   static constexpr bool isStmt{false};
 };
 template <typename A>
if constexpr (lower::pft::isFunctionLike<A>) {
       if constexpr (lower::pft::isConstructStmt<T> ||
                     lower::pft::isOtherStmt<T>) {
         addEvaluation(lower::pft::Evaluation{
             stmt.unwrapped, pftParentStack.back(), stmt.position, stmt.label});
         return false;
       } else if constexpr (std::is_same_v<T, parser::ActionStmt>) {
         return std::visit(
             common::visitors{
-                [&](const common::Indirection<parser::CallStmt> &x) {
+                [&](const parser::Indirection<parser::CallStmt> &x) {
                   addEvaluation(lower::pft::Evaluation{
                       removeIndirection(x), pftParentStack.back(),
                       stmt.position, stmt.label});
                   checkForRoundingModeCall(x.value());
                   return true;
                 },
-                [&](const common::Indirection<parser::IfStmt> &x) {
+                [&](const parser::Indirection<parser::IfStmt> &x) {
                   convertIfStmt(x.value(), stmt.position, stmt.label);
                   return false;
                 },
                 [&](const auto &x) {
                   addEvaluation(lower::pft::Evaluation{
                       removeIndirection(x), pftParentStack.back(),
                       stmt.position, stmt.label});
                   return true;

 
 //===----------------------------------------------------------------------===//
 // FunctionLikeUnit implementation
 //===----------------------------------------------------------------------===//
 
 Fortran::lower::pft::FunctionLikeUnit::FunctionLikeUnit(
     const parser::MainProgram &func, const lower::pft::PftNode &parent,
     const semantics::SemanticsContext &semanticsContext)
-    : ProgramUnit{func, parent}, endStmt{
-                                     getFunctionStmt<parser::EndProgramStmt>(
-                                         func)} {
+    : ProgramUnit{func, parent},
+      endStmt{getFunctionStmt<parser::EndProgramStmt>(func)} {
   const auto &programStmt =
       std::get<std::optional<parser::Statement<parser::ProgramStmt>>>(func.t);
   if (programStmt.has_value()) {
     beginStmt = FunctionStatement(programStmt.value());
     const semantics::Symbol *symbol = getSymbol(*beginStmt);
     entryPointList[0].first = symbol;
     scope = symbol->scope();
   } else {

 
 Fortran::lower::pft::ModuleLikeUnit::ModuleLikeUnit(
     const parser::Module &m, const lower::pft::PftNode &parent)
     : ProgramUnit{m, parent}, beginStmt{getModuleStmt<parser::ModuleStmt>(m)},
       endStmt{getModuleStmt<parser::EndModuleStmt>(m)} {}
 
 Fortran::lower::pft::ModuleLikeUnit::ModuleLikeUnit(
     const parser::Submodule &m, const lower::pft::PftNode &parent)
-    : ProgramUnit{m, parent}, beginStmt{getModuleStmt<parser::SubmoduleStmt>(
-                                  m)},
+    : ProgramUnit{m, parent},
+      beginStmt{getModuleStmt<parser::SubmoduleStmt>(m)},
       endStmt{getModuleStmt<parser::EndSubmoduleStmt>(m)} {}
 
 parser::CharBlock
 Fortran::lower::pft::ModuleLikeUnit::getStartingSourceLoc() const {
   return stmtSourceLoc(beginStmt);
 }
 const Fortran::semantics::Scope &
 Fortran::lower::pft::ModuleLikeUnit::getScope() const {

flang/lib/Parser/basic-parsers.h

 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);
+  return construct<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) {

flang/lib/Parser/parse-tree.cpp

 //===-- lib/Parser/parse-tree.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 "flang/Parser/parse-tree.h"
 #include "flang/Common/idioms.h"
-#include "flang/Common/indirection.h"
 #include "flang/Parser/tools.h"
 #include "flang/Parser/user-state.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 
 namespace Fortran::parser {
 
 // R867

 }
 
 // R901 designator
 bool Designator::EndsInBareName() const {
   return common::visit(
       common::visitors{
           [](const DataRef &dr) {
             return std::holds_alternative<Name>(dr.u) ||
-                std::holds_alternative<common::Indirection<StructureComponent>>(
-                    dr.u);
+                std::holds_alternative<Indirection<StructureComponent>>(dr.u);
           },
           [](const Substring &) { return false; },
       },
       u);
 }
 
 // R911 data-ref -> part-ref [% part-ref]...
 DataRef::DataRef(std::list<PartRef> &&prl) : u{std::move(prl.front().name)} {
   for (bool first{true}; !prl.empty(); first = false, prl.pop_front()) {
     PartRef &pr{prl.front()};
     if (!first) {
-      u = common::Indirection<StructureComponent>::Make(
+      u = Indirection<StructureComponent>::Make(
           std::move(*this), std::move(pr.name));
     }
     if (!pr.subscripts.empty()) {
-      u = common::Indirection<ArrayElement>::Make(
+      u = Indirection<ArrayElement>::Make(
           std::move(*this), std::move(pr.subscripts));
     }
     if (pr.imageSelector) {
-      u = common::Indirection<CoindexedNamedObject>::Make(
+      u = Indirection<CoindexedNamedObject>::Make(
           std::move(*this), std::move(*pr.imageSelector));
     }
   }
 }
 
 // R1001 - R1022 expression
-Expr::Expr(Designator &&x)
-    : u{common::Indirection<Designator>::Make(std::move(x))} {}
+Expr::Expr(Designator &&x) : u{Indirection<Designator>::Make(std::move(x))} {}
 Expr::Expr(FunctionReference &&x)
-    : u{common::Indirection<FunctionReference>::Make(std::move(x))} {}
+    : u{Indirection<FunctionReference>::Make(std::move(x))} {}
 
 const std::optional<LoopControl> &DoConstruct::GetLoopControl() const {
   const NonLabelDoStmt &doStmt{
       std::get<Statement<NonLabelDoStmt>>(t).statement};
   const std::optional<LoopControl> &control{
       std::get<std::optional<LoopControl>>(doStmt.t)};
   return control;
 }
bool DoConstruct::IsDoConcurrent() const {
   return control && std::holds_alternative<LoopControl::Concurrent>(control->u);
 }
 
 static Designator MakeArrayElementRef(
     const Name &name, std::list<Expr> &&subscripts) {
   ArrayElement arrayElement{DataRef{Name{name}}, std::list<SectionSubscript>{}};
   for (Expr &expr : subscripts) {
     arrayElement.subscripts.push_back(
-        SectionSubscript{Integer{common::Indirection{std::move(expr)}}});
+        SectionSubscript{Integer{Indirection<Expr>{std::move(expr)}}});
   }
-  return Designator{DataRef{common::Indirection{std::move(arrayElement)}}};
+  return Designator{
+      DataRef{Indirection<ArrayElement>{std::move(arrayElement)}}};
 }
 
 static Designator MakeArrayElementRef(
     StructureComponent &&sc, std::list<Expr> &&subscripts) {
-  ArrayElement arrayElement{DataRef{common::Indirection{std::move(sc)}},
+  ArrayElement arrayElement{
+      DataRef{Indirection<StructureComponent>{std::move(sc)}},
       std::list<SectionSubscript>{}};
   for (Expr &expr : subscripts) {
     arrayElement.subscripts.push_back(
-        SectionSubscript{Integer{common::Indirection{std::move(expr)}}});
+        SectionSubscript{Integer{Indirection<Expr>{std::move(expr)}}});
   }
-  return Designator{DataRef{common::Indirection{std::move(arrayElement)}}};
+  return Designator{
+      DataRef{Indirection<ArrayElement>{std::move(arrayElement)}}};
 }
 
 // Set source in any type of node that has it.
 template <typename T> T WithSource(CharBlock source, T &&x) {
   x.source = source;
   return std::move(x);
 }
 
 static Expr ActualArgToExpr(ActualArgSpec &arg) {
   return common::visit(
       common::visitors{
-          [&](common::Indirection<Expr> &y) { return std::move(y.value()); },
-          [&](common::Indirection<Variable> &y) {
-            return common::visit(
-                common::visitors{
-                    [&](common::Indirection<Designator> &z) {
-                      return WithSource(
-                          z.value().source, Expr{std::move(z.value())});
-                    },
-                    [&](common::Indirection<FunctionReference> &z) {
-                      return WithSource(
-                          z.value().source, Expr{std::move(z.value())});
+          [&](Indirection<Expr> &y) { return std::move(y.value()); },
+          [&](Indirection<Variable> &y) {
+            return common::visit(common::visitors{
+                                     [&](Indirection<Designator> &z) {
+                                       return WithSource(z.value().source,
+                                           Expr{std::move(z.value())});
+                                     },
+                                     [&](Indirection<FunctionReference> &z) {
+                                       return WithSource(z.value().source,
+                                           Expr{std::move(z.value())});
                                      },
                                  },
                 y.value().u);
           },
           [&](auto &) -> Expr { common::die("unexpected type"); },
       },
       std::get<ActualArg>(arg.t).u);
 }
 
 Designator FunctionReference::ConvertToArrayElementRef() {
return common::visit(
                 MakeArrayElementRef(std::move(pcr.v.thing), std::move(args)));
           },
       },
       std::get<ProcedureDesignator>(v.t).u);
 }
 
 StructureConstructor FunctionReference::ConvertToStructureConstructor(
     const semantics::DerivedTypeSpec &derived) {
-  Name name{std::get<parser::Name>(std::get<ProcedureDesignator>(v.t).u)};
+  Name name{std::get<Name>(std::get<ProcedureDesignator>(v.t).u)};
   std::list<ComponentSpec> components;
   for (auto &arg : std::get<std::list<ActualArgSpec>>(v.t)) {
     std::optional<Keyword> keyword;
     if (auto &kw{std::get<std::optional<Keyword>>(arg.t)}) {
       keyword.emplace(Keyword{Name{kw->v}});
     }
     components.emplace_back(
         std::move(keyword), ComponentDataSource{ActualArgToExpr(arg)});
   }
   DerivedTypeSpec spec{std::move(name), std::list<TypeParamSpec>{}};
   spec.derivedTypeSpec = &derived;
   return StructureConstructor{std::move(spec), std::move(components)};
 }
 
 StructureConstructor ArrayElement::ConvertToStructureConstructor(
     const semantics::DerivedTypeSpec &derived) {
-  Name name{std::get<parser::Name>(base.u)};
+  Name name{std::get<Name>(base.u)};
   std::list<ComponentSpec> components;
   for (auto &subscript : subscripts) {
     components.emplace_back(std::optional<Keyword>{},
         ComponentDataSource{std::move(*Unwrap<Expr>(subscript))});
   }
   DerivedTypeSpec spec{std::move(name), std::list<TypeParamSpec>{}};
   spec.derivedTypeSpec = &derived;
   return StructureConstructor{std::move(spec), std::move(components)};
for (const Name &arg : funcArgs) {
     source.ExtendToCover(arg.source);
   }
   CHECK(*source.end() == ')');
   source = CharBlock{source.begin(), source.end() + 1};
   FunctionReference funcRef{
       Call{ProcedureDesignator{Name{funcName.source, funcName.symbol}},
           std::move(actuals)}};
   funcRef.source = source;
-  auto variable{Variable{common::Indirection{std::move(funcRef)}}};
+  auto variable{Variable{Indirection<FunctionReference>{std::move(funcRef)}}};
   return Statement{std::nullopt,
-      ActionStmt{common::Indirection{
+      ActionStmt{Indirection<AssignmentStmt>{
           AssignmentStmt{std::move(variable), std::move(funcExpr)}}}};
 }
 
 CharBlock Variable::GetSource() const {
-  return common::visit(
-      common::visitors{
-          [&](const common::Indirection<Designator> &des) {
+  return common::visit(common::visitors{
+                           [&](const Indirection<Designator> &des) {
                              return des.value().source;
                            },
-          [&](const common::Indirection<parser::FunctionReference> &call) {
+                           [&](const Indirection<FunctionReference> &call) {
                              return call.value().source;
                            },
                        },
       u);
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Name &x) {
   return os << x.ToString();
 }
 } // namespace Fortran::parser

flang/lib/Parser/tools.cpp

 const Name &GetLastName(const StructureComponent &x) {
   return GetLastName(x.component);
 }
 
 const Name &GetLastName(const DataRef &x) {
   return common::visit(
       common::visitors{
           [](const Name &name) -> const Name & { return name; },
-          [](const common::Indirection<StructureComponent> &sc)
-              -> const Name & { return GetLastName(sc.value()); },
-          [](const common::Indirection<ArrayElement> &sc) -> const Name & {
+          [](const Indirection<StructureComponent> &sc) -> const Name & {
+            return GetLastName(sc.value());
+          },
+          [](const Indirection<ArrayElement> &sc) -> const Name & {
             return GetLastName(sc.value().base);
           },
-          [](const common::Indirection<CoindexedNamedObject> &ci)
-              -> const Name & { return GetLastName(ci.value().base); },
+          [](const Indirection<CoindexedNamedObject> &ci) -> const Name & {
+            return GetLastName(ci.value().base);
+          },
       },
       x.u);
 }
 
 const Name &GetLastName(const Substring &x) {
   return GetLastName(std::get<DataRef>(x.t));
 }
 

 const Name &GetFirstName(const StructureComponent &x) {
   return GetFirstName(x.base);
 }
 
 const Name &GetFirstName(const DataRef &x) {
   return common::visit(
       common::visitors{
           [](const Name &name) -> const Name & { return name; },
-          [](const common::Indirection<StructureComponent> &sc)
-              -> const Name & { return GetFirstName(sc.value()); },
-          [](const common::Indirection<ArrayElement> &sc) -> const Name & {
+          [](const Indirection<StructureComponent> &sc) -> const Name & {
+            return GetFirstName(sc.value());
+          },
+          [](const Indirection<ArrayElement> &sc) -> const Name & {
             return GetFirstName(sc.value().base);
           },
-          [](const common::Indirection<CoindexedNamedObject> &ci)
-              -> const Name & { return GetFirstName(ci.value().base); },
+          [](const Indirection<CoindexedNamedObject> &ci) -> const Name & {
+            return GetFirstName(ci.value().base);
+          },
       },
       x.u);
 }
 
 const Name &GetFirstName(const Substring &x) {
   return GetFirstName(std::get<DataRef>(x.t));
 }
 
return common::visit(
       },
       x.u);
 }
 
 const CoindexedNamedObject *GetCoindexedNamedObject(const DataRef &base) {
   return common::visit(
       common::visitors{
           [](const Name &) -> const CoindexedNamedObject * { return nullptr; },
-          [](const common::Indirection<CoindexedNamedObject> &x)
+          [](const Indirection<CoindexedNamedObject> &x)
               -> const CoindexedNamedObject * { return &x.value(); },
           [](const auto &x) -> const CoindexedNamedObject * {
             return GetCoindexedNamedObject(x.value().base);
           },
       },
       base.u);
 }
 const CoindexedNamedObject *GetCoindexedNamedObject(
     const Designator &designator) {
   return common::visit(
       common::visitors{
           [](const DataRef &x) -> const CoindexedNamedObject * {
             return GetCoindexedNamedObject(x);
           },
           [](const Substring &x) -> const CoindexedNamedObject * {
             return GetCoindexedNamedObject(std::get<DataRef>(x.t));
           },
       },
       designator.u);
 }
 const CoindexedNamedObject *GetCoindexedNamedObject(const Variable &variable) {
   return common::visit(
       common::visitors{
-          [](const common::Indirection<Designator> &designator)
+          [](const Indirection<Designator> &designator)
               -> const CoindexedNamedObject * {
             return GetCoindexedNamedObject(designator.value());
           },
           [](const auto &) -> const CoindexedNamedObject * { return nullptr; },
       },
       variable.u);
 }
 const CoindexedNamedObject *GetCoindexedNamedObject(

flang/lib/Parser/unparse.cpp

if (!attrs.empty() ||
             std::none_of(
                 decls.begin(), decls.end(), [](const ComponentOrFill &c) {
                   return common::visit(
                       common::visitors{
                           [](const ComponentDecl &d) {
                             const auto &init{
                                 std::get<std::optional<Initialization>>(d.t)};
                             return init &&
-                                std::holds_alternative<std::list<
-                                    common::Indirection<DataStmtValue>>>(
+                                std::holds_alternative<
+                                    std::list<Indirection<DataStmtValue>>>(
                                     init->u);
                           },
                           [](const FillDecl &) { return false; },
                       },
                       c.u);
                 }))) {
       Put(" ::");
     }
void Unparse(const ProcComponentDefStmt &x) { // R741
     Walk(", ", std::get<std::list<ProcComponentAttrSpec>>(x.t), ", ");
     Put(" :: "), Walk(std::get<std::list<ProcDecl>>(x.t), ", ");
   }
   void Unparse(const NoPass &) { // R742
     Word("NOPASS");
   }
   void Unparse(const Pass &x) { Word("PASS"), Walk("(", x.v, ")"); }
   void Unparse(const Initialization &x) { // R743 & R805
-    common::visit(
-        common::visitors{
+    common::visit(common::visitors{
                       [&](const ConstantExpr &y) { Put(" = "), Walk(y); },
                       [&](const NullInit &y) { Put(" => "), Walk(y); },
                       [&](const InitialDataTarget &y) { Put(" => "), Walk(y); },
-            [&](const std::list<common::Indirection<DataStmtValue>> &y) {
+                      [&](const std::list<Indirection<DataStmtValue>> &y) {
                         Walk("/", y, ", ", "/");
                       },
                   },
         x.u);
   }
   void Unparse(const PrivateStmt &) { // R745
     Word("PRIVATE");
   }
   void Unparse(const TypeBoundProcedureStmt::WithoutInterface &x) { // R749
     Word("PROCEDURE"), Walk(", ", x.attributes, ", ");
     Put(" :: "), Walk(x.declarations, ", ");
   }
   void Unparse(const TypeBoundProcedureStmt::WithInterface &x) {
     Word("PROCEDURE("), Walk(x.interfaceName), Put("), ");
     Walk(x.attributes);
     Put(" :: "), Walk(x.bindingNames, ", ");
   }
   void Unparse(const TypeBoundProcDecl &x) { // R750
     Walk(std::get<Name>(x.t));
     Walk(" => ", std::get<std::optional<Name>>(x.t));
   }
   void Unparse(const TypeBoundGenericStmt &x) { // R751
     Word("GENERIC"), Walk(", ", std::get<std::optional<AccessSpec>>(x.t));
-    Put(" :: "), Walk(std::get<common::Indirection<GenericSpec>>(x.t));
+    Put(" :: "), Walk(std::get<Indirection<GenericSpec>>(x.t));
     Put(" => "), Walk(std::get<std::list<Name>>(x.t), ", ");
   }
   void Post(const BindAttr::Deferred &) { Word("DEFERRED"); } // R752
   void Post(const BindAttr::Non_Overridable &) { Word("NON_OVERRIDABLE"); }
   void Unparse(const FinalProcedureStmt &x) { // R753
     Word("FINAL :: "), Walk(x.v, ", ");
   }
   void Unparse(const DerivedTypeSpec &x) { // R754
public:
 
   void Unparse(const TypeDeclarationStmt &x) { // R801
     const auto &dts{std::get<DeclarationTypeSpec>(x.t)};
     const auto &attrs{std::get<std::list<AttrSpec>>(x.t)};
     const auto &decls{std::get<std::list<EntityDecl>>(x.t)};
     Walk(dts), Walk(", ", attrs, ", ");
 
     static const auto isInitializerOldStyle{[](const Initialization &i) {
-      return std::holds_alternative<
-          std::list<common::Indirection<DataStmtValue>>>(i.u);
+      return std::holds_alternative<std::list<Indirection<DataStmtValue>>>(i.u);
     }};
     static const auto hasAssignmentInitializer{[](const EntityDecl &d) {
       // Does a declaration have a new-style =x initializer?
       const auto &init{std::get<std::optional<Initialization>>(d.t)};
       return init && !isInitializerOldStyle(*init);
     }};
     static const auto hasSlashDelimitedInitializer{[](const EntityDecl &d) {
       // Does a declaration have an old-style /x/ initializer?
public:
   void Unparse(const ElsewhereStmt &x) { // R1048
     Outdent(), Word("ELSEWHERE"), Walk(" ", x.v), Indent();
   }
   void Unparse(const EndWhereStmt &x) { // R1049
     Outdent(), Word("END WHERE"), Walk(" ", x.v);
   }
   void Unparse(const ForallConstructStmt &x) { // R1051
     Walk(std::get<std::optional<Name>>(x.t), ": ");
-    Word("FORALL"), Walk(std::get<common::Indirection<ConcurrentHeader>>(x.t));
+    Word("FORALL"), Walk(std::get<Indirection<ConcurrentHeader>>(x.t));
     Indent();
   }
   void Unparse(const EndForallStmt &x) { // R1054
     Outdent(), Word("END FORALL"), Walk(" ", x.v);
   }
   void Before(const ForallStmt &) { // R1055
     Word("FORALL");
   }

flang/lib/Semantics/canonicalize-do.cpp

void Post(Block &block) {
     std::vector<LabelInfo> stack;
     for (auto i{block.begin()}, end{block.end()}; i != end; ++i) {
       if (auto *executableConstruct{std::get_if<ExecutableConstruct>(&i->u)}) {
         common::visit(
             common::visitors{
                 [](auto &) {},
                 // Labels on end-stmt of constructs are accepted by f18 as an
                 // extension.
-                [&](common::Indirection<AssociateConstruct> &associate) {
+                [&](Indirection<AssociateConstruct> &associate) {
                   CanonicalizeIfMatch(block, stack, i,
                       std::get<Statement<EndAssociateStmt>>(
                           associate.value().t));
                 },
-                [&](common::Indirection<BlockConstruct> &blockConstruct) {
+                [&](Indirection<BlockConstruct> &blockConstruct) {
                   CanonicalizeIfMatch(block, stack, i,
                       std::get<Statement<EndBlockStmt>>(
                           blockConstruct.value().t));
                 },
-                [&](common::Indirection<ChangeTeamConstruct> &changeTeam) {
+                [&](Indirection<ChangeTeamConstruct> &changeTeam) {
                   CanonicalizeIfMatch(block, stack, i,
                       std::get<Statement<EndChangeTeamStmt>>(
                           changeTeam.value().t));
                 },
-                [&](common::Indirection<CriticalConstruct> &critical) {
+                [&](Indirection<CriticalConstruct> &critical) {
                   CanonicalizeIfMatch(block, stack, i,
                       std::get<Statement<EndCriticalStmt>>(critical.value().t));
                 },
-                [&](common::Indirection<DoConstruct> &doConstruct) {
+                [&](Indirection<DoConstruct> &doConstruct) {
                   CanonicalizeIfMatch(block, stack, i,
                       std::get<Statement<EndDoStmt>>(doConstruct.value().t));
                 },
-                [&](common::Indirection<IfConstruct> &ifConstruct) {
+                [&](Indirection<IfConstruct> &ifConstruct) {
                   CanonicalizeIfMatch(block, stack, i,
                       std::get<Statement<EndIfStmt>>(ifConstruct.value().t));
                 },
-                [&](common::Indirection<CaseConstruct> &caseConstruct) {
+                [&](Indirection<CaseConstruct> &caseConstruct) {
                   CanonicalizeIfMatch(block, stack, i,
                       std::get<Statement<EndSelectStmt>>(
                           caseConstruct.value().t));
                 },
-                [&](common::Indirection<SelectRankConstruct> &selectRank) {
+                [&](Indirection<SelectRankConstruct> &selectRank) {
                   CanonicalizeIfMatch(block, stack, i,
                       std::get<Statement<EndSelectStmt>>(selectRank.value().t));
                 },
-                [&](common::Indirection<SelectTypeConstruct> &selectType) {
+                [&](Indirection<SelectTypeConstruct> &selectType) {
                   CanonicalizeIfMatch(block, stack, i,
                       std::get<Statement<EndSelectStmt>>(selectType.value().t));
                 },
-                [&](common::Indirection<ForallConstruct> &forall) {
+                [&](Indirection<ForallConstruct> &forall) {
                   CanonicalizeIfMatch(block, stack, i,
                       std::get<Statement<EndForallStmt>>(forall.value().t));
                 },
-                [&](common::Indirection<WhereConstruct> &where) {
+                [&](Indirection<WhereConstruct> &where) {
                   CanonicalizeIfMatch(block, stack, i,
                       std::get<Statement<EndWhereStmt>>(where.value().t));
                 },
-                [&](Statement<common::Indirection<LabelDoStmt>> &labelDoStmt) {
+                [&](Statement<Indirection<LabelDoStmt>> &labelDoStmt) {
                   auto &label{std::get<Label>(labelDoStmt.statement.value().t)};
                   stack.push_back(LabelInfo{i, label});
                 },
-                [&](Statement<common::Indirection<EndDoStmt>> &endDoStmt) {
+                [&](Statement<Indirection<EndDoStmt>> &endDoStmt) {
                   CanonicalizeIfMatch(block, stack, i, endDoStmt);
                 },
                 [&](Statement<ActionStmt> &actionStmt) {
                   CanonicalizeIfMatch(block, stack, i, actionStmt);
                 },
             },
             executableConstruct->u);
       }
     }
   }
 
 private:
   template <typename T>
   void CanonicalizeIfMatch(Block &originalBlock, std::vector<LabelInfo> &stack,
       Block::iterator &i, Statement<T> &statement) {
     if (!stack.empty() && statement.label &&
         stack.back().label == *statement.label) {
       auto currentLabel{stack.back().label};
-      if constexpr (std::is_same_v<T, common::Indirection<EndDoStmt>>) {
+      if constexpr (std::is_same_v<T, Indirection<EndDoStmt>>) {
         std::get<ExecutableConstruct>(i->u).u = Statement<ActionStmt>{
             std::optional<Label>{currentLabel}, ContinueStmt{}};
       }
       auto next{++i};
       do {
         Block block;
         auto doLoop{stack.back().iter};
-        auto originalSource{
-            std::get<Statement<common::Indirection<LabelDoStmt>>>(
-                std::get<ExecutableConstruct>(doLoop->u).u)
+        auto originalSource{std::get<Statement<Indirection<LabelDoStmt>>>(
                                 .source};
         block.splice(block.begin(), originalBlock, ++stack.back().iter, next);
-        auto &labelDo{std::get<Statement<common::Indirection<LabelDoStmt>>>(
+        auto &labelDo{std::get<Statement<Indirection<LabelDoStmt>>>(
             std::get<ExecutableConstruct>(doLoop->u).u)};
         auto &loopControl{
             std::get<std::optional<LoopControl>>(labelDo.statement.value().t)};
         auto &name{std::get<std::optional<Name>>(labelDo.statement.value().t)};
         Statement<NonLabelDoStmt> nonLabelDoStmt{std::move(labelDo.label),
             NonLabelDoStmt{
                 std::make_tuple(common::Clone(name), std::move(loopControl))}};
         nonLabelDoStmt.source = originalSource;
-        std::get<ExecutableConstruct>(doLoop->u).u =
-            common::Indirection<DoConstruct>{
-                std::make_tuple(std::move(nonLabelDoStmt), std::move(block),
-                    Statement<EndDoStmt>{
-                        std::optional<Label>{}, EndDoStmt{std::move(name)}})};
+        std::get<ExecutableConstruct>(doLoop->u).u = Indirection<DoConstruct>{
         stack.pop_back();
       } while (!stack.empty() && stack.back().label == currentLabel);
       i = --next;
     }
   }
 };
 
 bool CanonicalizeDo(Program &program) {
   CanonicalizationOfDoLoops canonicalizationOfDoLoops;
   Walk(program, canonicalizationOfDoLoops);
   return true;
 }
 
 } // namespace Fortran::parser

flang/lib/Semantics/canonicalize-omp.cpp

void Post(parser::Block &block) {
     } // Block list
   }
 
   void Post(parser::ExecutionPart &body) { RewriteOmpAllocations(body); }
 
 private:
   template <typename T> T *GetConstructIf(parser::ExecutionPartConstruct &x) {
     if (auto *y{std::get_if<parser::ExecutableConstruct>(&x.u)}) {
-      if (auto *z{std::get_if<common::Indirection<T>>(&y->u)}) {
+      if (auto *z{std::get_if<parser::Indirection<T>>(&y->u)}) {
         return &z->value();
       }
     }
     return nullptr;
   }
 
   template <typename T> T *GetOmpIf(parser::ExecutionPartConstruct &x) {
     if (auto *construct{GetConstructIf<parser::OpenMPConstruct>(x)}) {

flang/lib/Semantics/check-cuda.cpp

if constexpr (ConstraintTrait<A>) {
       return WhyNotOk(x.u);
     } else if constexpr (TupleTrait<A>) {
       return WhyNotOk(x.t);
     } else {
       return parser::MessageFormattedText{
           "Statement may not appear in device code"_err_en_US};
     }
   }
-  template <typename A>
-  static MaybeMsg WhyNotOk(const common::Indirection<A> &x) {
+  template <typename A, bool COPY>
+  static MaybeMsg WhyNotOk(const common::Indirection<A, COPY> &x) {
     return WhyNotOk(x.value());
   }
   template <typename... As>
   static MaybeMsg WhyNotOk(const std::variant<As...> &x) {
     return common::visit([](const auto &x) { return WhyNotOk(x); }, x);
   }
   template <std::size_t J = 0, typename... As>
   static MaybeMsg WhyNotOk(const std::tuple<As...> &x) {
void Check(const parser::Block &block) {
     }
   }
 
 private:
   void Check(const parser::ExecutionPartConstruct &epc) {
     common::visit(
         common::visitors{
             [&](const parser::ExecutableConstruct &x) { Check(x); },
-            [&](const parser::Statement<common::Indirection<parser::EntryStmt>>
+            [&](const parser::Statement<parser::Indirection<parser::EntryStmt>>
                     &x) {
               context_.Say(x.source,
                   "Device code may not contain an ENTRY statement"_err_en_US);
             },
-            [](const parser::Statement<common::Indirection<parser::FormatStmt>>
+            [](const parser::Statement<parser::Indirection<parser::FormatStmt>>
                     &) {},
-            [](const parser::Statement<common::Indirection<parser::DataStmt>>
+            [](const parser::Statement<parser::Indirection<parser::DataStmt>>
                     &) {},
             [](const parser::Statement<
-                common::Indirection<parser::NamelistStmt>> &) {},
+                parser::Indirection<parser::NamelistStmt>> &) {},
             [](const parser::ErrorRecovery &) {},
         },
         epc.u);
   }
   void Check(const parser::ExecutableConstruct &ec) {
     common::visit(
         common::visitors{
             [&](const parser::Statement<parser::ActionStmt> &stmt) {
               Check(stmt.statement, stmt.source);
             },
-            [&](const common::Indirection<parser::DoConstruct> &x) {
+            [&](const parser::Indirection<parser::DoConstruct> &x) {
               if (const std::optional<parser::LoopControl> &control{
                       x.value().GetLoopControl()}) {
                 common::visit([&](const auto &y) { Check(y); }, control->u);
               }
               Check(std::get<parser::Block>(x.value().t));
             },
-            [&](const common::Indirection<parser::BlockConstruct> &x) {
+            [&](const parser::Indirection<parser::BlockConstruct> &x) {
               Check(std::get<parser::Block>(x.value().t));
             },
-            [&](const common::Indirection<parser::IfConstruct> &x) {
+            [&](const parser::Indirection<parser::IfConstruct> &x) {
               Check(x.value());
             },
             [&](const auto &x) {
               if (auto source{parser::GetSource(x)}) {
                 context_.Say(*source,
                     "Statement may not appear in device code"_err_en_US);
               }
             },
static int DoConstructTightNesting(
   if (!doConstruct || !doConstruct->IsDoNormal()) {
     return 0;
   }
   innerBlock = &std::get<parser::Block>(doConstruct->t);
   if (innerBlock->size() == 1) {
     if (const auto *execConstruct{
             std::get_if<parser::ExecutableConstruct>(&innerBlock->front().u)}) {
       if (const auto *next{
-              std::get_if<common::Indirection<parser::DoConstruct>>(
+              std::get_if<parser::Indirection<parser::DoConstruct>>(
                   &execConstruct->u)}) {
         return 1 + DoConstructTightNesting(&next->value(), innerBlock);
       }
     }
   }
   return 1;
 }
 

flang/lib/Semantics/check-data.cpp

 
 static bool IsValidDataObject(const SomeExpr &expr) { // C878, C879
   return !evaluate::IsConstantExpr(expr) &&
       (evaluate::IsVariable(expr) || evaluate::IsProcedurePointer(expr));
 }
 
 void DataChecker::Leave(const parser::DataIDoObject &object) {
   if (const auto *designator{
-          std::get_if<parser::Scalar<common::Indirection<parser::Designator>>>(
+          std::get_if<parser::Scalar<parser::Indirection<parser::Designator>>>(
               &object.u)}) {
     if (MaybeExpr expr{exprAnalyzer_.Analyze(*designator)}) {
       auto source{designator->thing.value().source};
       DataVarChecker checker{exprAnalyzer_.context(), source};
       if (checker(*expr)) {
         if (checker.HasComponentWithoutSubscripts()) { // C880
           exprAnalyzer_.context().Say(source,
               "Data implied do structure component must be subscripted"_err_en_US);

 
 // Handle legacy DATA-style initialization, e.g. REAL PI/3.14159/, for
 // variables and components (esp. for DEC STRUCTUREs)
 template <typename A> void DataChecker::LegacyDataInit(const A &decl) {
   if (const auto &init{
           std::get<std::optional<parser::Initialization>>(decl.t)}) {
     const Symbol *name{std::get<parser::Name>(decl.t).symbol};
     const auto *list{
-        std::get_if<std::list<common::Indirection<parser::DataStmtValue>>>(
+        std::get_if<std::list<parser::Indirection<parser::DataStmtValue>>>(
             &init->u)};
     if (name && list) {
       AccumulateDataInitializations(inits_, exprAnalyzer_, *name, *list);
     }
   }
 }
 
 void DataChecker::Leave(const parser::ComponentDecl &decl) {

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

static const parser::ConcurrentHeader &GetConcurrentHeader(
   const auto &concurrent{
       std::get<parser::LoopControl::Concurrent>(loopControl.u)};
   return std::get<parser::ConcurrentHeader>(concurrent.t);
 }
 static const parser::ConcurrentHeader &GetConcurrentHeader(
     const parser::ForallConstruct &construct) {
   const auto &stmt{
       std::get<parser::Statement<parser::ForallConstructStmt>>(construct.t)};
-  return std::get<common::Indirection<parser::ConcurrentHeader>>(
+  return std::get<parser::Indirection<parser::ConcurrentHeader>>(
       stmt.statement.t)
       .value();
 }
 static const parser::ConcurrentHeader &GetConcurrentHeader(
     const parser::ForallStmt &stmt) {
-  return std::get<common::Indirection<parser::ConcurrentHeader>>(stmt.t)
+  return std::get<parser::Indirection<parser::ConcurrentHeader>>(stmt.t)
       .value();
 }
 template <typename T>
 static const std::list<parser::ConcurrentControl> &GetControls(const T &x) {
   return std::get<std::list<parser::ConcurrentControl>>(
       GetConcurrentHeader(x).t);
 }
 
static void SayWithDo(SemanticsContext &context, parser::CharBlock stmtLocation,
   context.Say(stmtLocation, message).Attach(doLocation, GetEnclosingDoMsg());
 }
 
 // 11.1.7.5 - enforce semantics constraints on a DO CONCURRENT loop body
 class DoConcurrentBodyEnforce {
 public:
   DoConcurrentBodyEnforce(
       SemanticsContext &context, parser::CharBlock doConcurrentSourcePosition)
-      : context_{context}, doConcurrentSourcePosition_{
-                               doConcurrentSourcePosition} {}
+      : context_{context},
+        doConcurrentSourcePosition_{doConcurrentSourcePosition} {}
   std::set<parser::Label> labels() { return labels_; }
   template <typename T> bool Pre(const T &x) {
     if (const auto *expr{GetExpr(context_, x)}) {
       if (auto bad{FindImpureCall(context_.foldingContext(), *expr)}) {
         context_.Say(currentStatementSourcePosition_,
             "Impure procedure '%s' may not be referenced in DO CONCURRENT"_err_en_US,
             *bad);
       }
for (const auto &checkedOptionalArg : checkedArgs) {
       if (parsedArgIter == parsedArgs.end()) {
         break; // No more parsed arguments, we're done.
       }
       const auto &parsedArg{std::get<parser::ActualArg>(parsedArgIter->t)};
       ++parsedArgIter;
       if (checkedOptionalArg) {
         const evaluate::ActualArgument &checkedArg{*checkedOptionalArg};
         if (const auto *parsedExpr{
-                std::get_if<common::Indirection<parser::Expr>>(&parsedArg.u)}) {
+                std::get_if<parser::Indirection<parser::Expr>>(&parsedArg.u)}) {
           CheckIfArgIsDoVar(checkedArg, parsedExpr->value().source, context_);
         }
       }
     }
   }
 }
 
 void DoForallChecker::Leave(const parser::ConnectSpec &connectSpec) {

flang/lib/Semantics/check-if-stmt.cpp

 #include "flang/Semantics/tools.h"
 
 namespace Fortran::semantics {
 
 void IfStmtChecker::Leave(const parser::IfStmt &ifStmt) {
   // C1143 Check that the action stmt is not an if stmt
   const auto &body{
       std::get<parser::UnlabeledStatement<parser::ActionStmt>>(ifStmt.t)};
-  if (std::holds_alternative<common::Indirection<parser::IfStmt>>(
+  if (std::holds_alternative<parser::Indirection<parser::IfStmt>>(
           body.statement.u)) {
     context_.Say(
         body.source, "IF statement is not allowed in IF statement"_err_en_US);
   }
 }
 
 } // namespace Fortran::semantics

flang/lib/Semantics/check-io.h

public:
   void Enter(const parser::OpenStmt &) { Init(IoStmtKind::Open); }
   void Enter(const parser::PrintStmt &) { Init(IoStmtKind::Print); }
   void Enter(const parser::ReadStmt &) { Init(IoStmtKind::Read); }
   void Enter(const parser::RewindStmt &) { Init(IoStmtKind::Rewind); }
   void Enter(const parser::WaitStmt &) { Init(IoStmtKind::Wait); }
   void Enter(const parser::WriteStmt &) { Init(IoStmtKind::Write); }
 
   void Enter(
-      const parser::Statement<common::Indirection<parser::FormatStmt>> &);
+      const parser::Statement<parser::Indirection<parser::FormatStmt>> &);
 
   void Enter(const parser::ConnectSpec &);
   void Enter(const parser::ConnectSpec::CharExpr &);
   void Enter(const parser::ConnectSpec::Newunit &);
   void Enter(const parser::ConnectSpec::Recl &);
   void Enter(const parser::EndLabel &);
   void Enter(const parser::EorLabel &);
   void Enter(const parser::ErrLabel &);

flang/lib/Semantics/check-io.cpp

if (formatCharBlock_.size()) {
     parser::CharBlock messageCharBlock{
         parser::CharBlock(formatCharBlock_.begin() + msg.offset, msg.length)};
     context_.Say(messageCharBlock, text);
   }
   return msg.isError && --errorAllowance_ <= 0;
 }
 
 void IoChecker::Enter(
-    const parser::Statement<common::Indirection<parser::FormatStmt>> &stmt) {
+    const parser::Statement<parser::Indirection<parser::FormatStmt>> &stmt) {
   if (!stmt.label) {
     context_.Say("Format statement must be labeled"_err_en_US); // C1301
   }
   const char *formatStart{static_cast<const char *>(
       std::memchr(stmt.source.begin(), '(', stmt.source.size()))};
   parser::CharBlock reporterCharBlock{formatStart, static_cast<std::size_t>(0)};
   FormatErrorReporter reporter{context_, reporterCharBlock};
   auto reporterWrapper{[&](const auto &msg) { return reporter.Say(msg); }};

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

bool ScheduleModifierHasType(const parser::OmpScheduleClause &,
       const parser::OmpScheduleModifierType::ModType &);
   void CheckAllowedMapTypes(const parser::OmpMapType::Type &,
       const std::list<parser::OmpMapType::Type> &);
   llvm::StringRef getClauseName(llvm::omp::Clause clause) override;
   llvm::StringRef getDirectiveName(llvm::omp::Directive directive) override;
 
   void CheckDependList(const parser::DataRef &);
   void CheckDependArraySection(
-      const common::Indirection<parser::ArrayElement> &, const parser::Name &);
+      const parser::Indirection<parser::ArrayElement> &, const parser::Name &);
   bool IsDataRefTypeParamInquiry(const parser::DataRef *dataRef);
   void CheckIsVarPartOfAnotherVar(
       const parser::CharBlock &source, const parser::OmpObjectList &objList);
   void CheckThreadprivateOrDeclareTargetVar(
       const parser::OmpObjectList &objList);
   void CheckSymbolNames(
       const parser::CharBlock &source, const parser::OmpObjectList &objList);
   void CheckIntentInPointer(

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

 }
 
 void OmpStructureChecker::CheckAtomicUpdateAssignmentStmt(
     const parser::AssignmentStmt &assignment) {
   const auto &expr{std::get<parser::Expr>(assignment.t)};
   const auto &var{std::get<parser::Variable>(assignment.t)};
   common::visit(
       common::visitors{
-          [&](const common::Indirection<parser::FunctionReference> &x) {
+          [&](const parser::Indirection<parser::FunctionReference> &x) {
             const auto &procedureDesignator{
                 std::get<parser::ProcedureDesignator>(x.value().v.t)};
             const parser::Name *name{
                 std::get_if<parser::Name>(&procedureDesignator.u)};
             if (name &&
                 !(name->source == "max" || name->source == "min" ||
                     name->source == "iand" || name->source == "ior" ||
                     name->source == "ieor")) {
               context_.Say(expr.source,
                   "Invalid intrinsic procedure name in "
                   "OpenMP ATOMIC (UPDATE) statement"_err_en_US);
             } else if (name) {
               bool foundMatch{false};
               if (auto varDesignatorIndirection =
-                      std::get_if<Fortran::common::Indirection<
+                      std::get_if<Fortran::parser::Indirection<
                           Fortran::parser::Designator>>(&var.u)) {
                 const auto &varDesignator = varDesignatorIndirection->value();
                 if (const auto *dataRef = std::get_if<Fortran::parser::DataRef>(
                         &varDesignator.u)) {
                   if (const auto *name =
                           std::get_if<Fortran::parser::Name>(&dataRef->u)) {
                     const auto &varSymbol = *name->symbol;
                     if (const auto *e{GetExpr(context_, expr)}) {

 void OmpStructureChecker::Enter(const parser::OmpClause::Depend &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_depend);
   if (const auto *inOut{std::get_if<parser::OmpDependClause::InOut>(&x.v.u)}) {
     const auto &designators{std::get<std::list<parser::Designator>>(inOut->t)};
     for (const auto &ele : designators) {
       if (const auto *dataRef{std::get_if<parser::DataRef>(&ele.u)}) {
         CheckDependList(*dataRef);
         if (const auto *arr{
-                std::get_if<common::Indirection<parser::ArrayElement>>(
+                std::get_if<parser::Indirection<parser::ArrayElement>>(
                     &dataRef->u)}) {
           CheckArraySection(arr->value(), GetLastName(*dataRef),
               llvm::omp::Clause::OMPC_depend);
         }
       }
     }
   }
 }

 llvm::StringRef OmpStructureChecker::getDirectiveName(
     llvm::omp::Directive directive) {
   return llvm::omp::getOpenMPDirectiveName(directive);
 }
 
 void OmpStructureChecker::CheckDependList(const parser::DataRef &d) {
   common::visit(
       common::visitors{
-          [&](const common::Indirection<parser::ArrayElement> &elem) {
+          [&](const parser::Indirection<parser::ArrayElement> &elem) {
             // Check if the base element is valid on Depend Clause
             CheckDependList(elem.value().base);
           },
-          [&](const common::Indirection<parser::StructureComponent> &) {
+          [&](const parser::Indirection<parser::StructureComponent> &) {
             context_.Say(GetContext().clauseSource,
                 "A variable that is part of another variable "
                 "(such as an element of a structure) but is not an array "
                 "element or an array section cannot appear in a DEPEND "
                 "clause"_err_en_US);
           },
-          [&](const common::Indirection<parser::CoindexedNamedObject> &) {
+          [&](const parser::Indirection<parser::CoindexedNamedObject> &) {
             context_.Say(GetContext().clauseSource,
                 "Coarrays are not supported in DEPEND clause"_err_en_US);
           },
           [&](const parser::Name &) { return; },
       },
       d.u);
 }
 

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

 //===-- lib/Semantics/data-to-inits.h -------------------------------------===//
 //
 // 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_DATA_TO_INITS_H_
 #define FORTRAN_SEMANTICS_DATA_TO_INITS_H_
 
 #include "flang/Common/default-kinds.h"
 #include "flang/Common/interval.h"
 #include "flang/Evaluate/initial-image.h"
+#include "flang/Parser/parse-tree.h"
 #include <list>
 #include <map>
 
-namespace Fortran::parser {
-struct DataStmtSet;
-struct DataStmtValue;
-} // namespace Fortran::parser
 namespace Fortran::evaluate {
 class ExpressionAnalyzer;
 }
 namespace Fortran::semantics {
 
 class Symbol;
 
 struct SymbolDataInitialization {

 // Matches DATA statement variables with their values and checks
 // compatibility.
 void AccumulateDataInitializations(DataInitializations &,
     evaluate::ExpressionAnalyzer &, const parser::DataStmtSet &);
 
 // For legacy DATA-style initialization extension: integer n(2)/1,2/
 void AccumulateDataInitializations(DataInitializations &,
     evaluate::ExpressionAnalyzer &, const Symbol &,
-    const std::list<common::Indirection<parser::DataStmtValue>> &);
+    const std::list<parser::Indirection<parser::DataStmtValue>> &);
 
 void ConvertToInitializers(
     DataInitializations &, evaluate::ExpressionAnalyzer &);
 
 } // namespace Fortran::semantics
 #endif // FORTRAN_SEMANTICS_DATA_TO_INITS_H_

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

private:
   const Scope *scope_{nullptr};
 };
 
 template <typename DSV>
 bool DataInitializationCompiler<DSV>::Scan(
     const parser::DataStmtObject &object) {
   return common::visit(
       common::visitors{
-          [&](const common::Indirection<parser::Variable> &var) {
+          [&](const parser::Indirection<parser::Variable> &var) {
             return Scan(var.value());
           },
           [&](const parser::DataImpliedDo &ido) { return Scan(ido); },
       },
       object.u);
 }
 
 template <typename DSV>
bool DataInitializationCompiler<DSV>::Scan(const parser::DataImpliedDo &ido) {
   return false;
 }
 
 template <typename DSV>
 bool DataInitializationCompiler<DSV>::Scan(
     const parser::DataIDoObject &object) {
   return common::visit(
       common::visitors{
-          [&](const parser::Scalar<common::Indirection<parser::Designator>>
+          [&](const parser::Scalar<parser::Indirection<parser::Designator>>
                   &var) { return Scan(var.thing.value()); },
-          [&](const common::Indirection<parser::DataImpliedDo> &ido) {
+          [&](const parser::Indirection<parser::DataImpliedDo> &ido) {
             return Scan(ido.value());
           },
       },
       object.u);
 }
 
 template <typename DSV>
 bool DataInitializationCompiler<DSV>::Scan(const Symbol &symbol) {
void AccumulateDataInitializations(DataInitializations &inits,
   if (scanner.HasSurplusValues()) {
     exprAnalyzer.context().Say(
         "DATA statement set has more values than objects"_err_en_US);
   }
 }
 
 void AccumulateDataInitializations(DataInitializations &inits,
     evaluate::ExpressionAnalyzer &exprAnalyzer, const Symbol &symbol,
-    const std::list<common::Indirection<parser::DataStmtValue>> &list) {
-  DataInitializationCompiler<common::Indirection<parser::DataStmtValue>>
+    const std::list<parser::Indirection<parser::DataStmtValue>> &list) {
+  DataInitializationCompiler<parser::Indirection<parser::DataStmtValue>>
       scanner{inits, exprAnalyzer, list};
   if (scanner.Scan(symbol) && scanner.HasSurplusValues()) {
     exprAnalyzer.context().Say(
         "DATA statement set has more values than objects"_err_en_US);
   }
 }
 
 // Looks for default derived type component initialization -- but

flang/lib/Semantics/expression.cpp

std::optional<Expr<SubscriptInteger>> DynamicTypeWithLength::LEN() const {
   } else {
     return GetCharLength();
   }
 }
 
 static std::optional<DynamicTypeWithLength> AnalyzeTypeSpec(
     const std::optional<parser::TypeSpec> &spec) {
   if (spec) {
-    if (const semantics::DeclTypeSpec *typeSpec{spec->declTypeSpec}) {
+    if (const semantics::DeclTypeSpec * typeSpec{spec->declTypeSpec}) {
       // Name resolution sets TypeSpec::declTypeSpec only when it's valid
       // (viz., an intrinsic type with valid known kind or a non-polymorphic
       // & non-ABSTRACT derived type).
-      if (const semantics::IntrinsicTypeSpec *intrinsic{
-              typeSpec->AsIntrinsic()}) {
+      if (const semantics::IntrinsicTypeSpec *
+          intrinsic{typeSpec->AsIntrinsic()}) {
         TypeCategory category{intrinsic->category()};
         if (auto optKind{ToInt64(intrinsic->kind())}) {
           int kind{static_cast<int>(*optKind)};
           if (category == TypeCategory::Character) {
             const semantics::CharacterTypeSpec &cts{
                 typeSpec->characterTypeSpec()};
             const semantics::ParamValue &len{cts.length()};
             // N.B. CHARACTER(LEN=*) is allowed in type-specs in ALLOCATE() &
             // type guards, but not in array constructors.
             return DynamicTypeWithLength{DynamicType{kind, len}};
           } else {
             return DynamicTypeWithLength{DynamicType{category, kind}};
           }
         }
-      } else if (const semantics::DerivedTypeSpec *derived{
-                     typeSpec->AsDerived()}) {
+      } else if (const semantics::DerivedTypeSpec *
+          derived{typeSpec->AsDerived()}) {
         return DynamicTypeWithLength{DynamicType{*derived}};
       }
     }
   }
   return std::nullopt;
 }
 
 // Utilities to set a source location, if we have one, on an actual argument,
ActualArguments &&GetActuals() {
     return std::move(actuals_);
   }
   const Expr<SomeType> &GetExpr(std::size_t i) const {
     return DEREF(actuals_.at(i).value().UnwrapExpr());
   }
   Expr<SomeType> &&MoveExpr(std::size_t i) {
     return std::move(DEREF(actuals_.at(i).value().UnwrapExpr()));
   }
-  void Analyze(const common::Indirection<parser::Expr> &x) {
+  void Analyze(const parser::Indirection<parser::Expr> &x) {
     Analyze(x.value());
   }
   void Analyze(const parser::Expr &x) {
     actuals_.emplace_back(AnalyzeExpr(x));
     SetArgSourceLocation(actuals_.back(), x.source);
     fatalErrors_ |= !actuals_.back();
   }
   void Analyze(const parser::Variable &);
if (subscripts == 0) {
     if (symbolRank != 0) {
       Say("Reference to rank-%d object '%s' has %d subscripts"_err_en_US,
           symbolRank, symbol.name(), subscripts);
     }
     return std::nullopt;
   } else if (const auto *object{
                  symbol.detailsIf<semantics::ObjectEntityDetails>()}) {
     // C928 & C1002
-    if (Triplet *last{std::get_if<Triplet>(&ref.subscript().back().u)}) {
+    if (Triplet * last{std::get_if<Triplet>(&ref.subscript().back().u)}) {
       if (!last->upper() && object->IsAssumedSize()) {
         Say("Assumed-size array '%s' must have explicit final "
             "subscript upper bound value"_err_en_US,
             symbol.name());
         return std::nullopt;
       }
     }
   } else {

 }
 
 // Parse tree correction after a substring S(j:k) was misparsed as an
 // array section.  Fortran substrings must have a range, not a
 // single index.
 static std::optional<parser::Substring> FixMisparsedSubstringDataRef(
     parser::DataRef &dataRef) {
   if (auto *ae{
-          std::get_if<common::Indirection<parser::ArrayElement>>(&dataRef.u)}) {
+          std::get_if<parser::Indirection<parser::ArrayElement>>(&dataRef.u)}) {
     // ...%a(j:k) and "a" is a character scalar
     parser::ArrayElement &arrElement{ae->value()};
     if (arrElement.subscripts.size() == 1) {
       if (auto *triplet{std::get_if<parser::SubscriptTriplet>(
               &arrElement.subscripts.front().u)}) {
         if (!std::get<2 /*stride*/>(triplet->t).has_value()) {
-          if (const Symbol *symbol{
-                  parser::GetLastName(arrElement.base).symbol}) {
+          if (const Symbol *
+              symbol{parser::GetLastName(arrElement.base).symbol}) {
             const Symbol &ultimate{symbol->GetUltimate()};
-            if (const semantics::DeclTypeSpec *type{ultimate.GetType()}) {
+            if (const semantics::DeclTypeSpec * type{ultimate.GetType()}) {
               if (!ultimate.IsObjectArray() &&
                   type->category() == semantics::DeclTypeSpec::Character) {
                 // The ambiguous S(j:k) was parsed as an array section
                 // reference, but it's now clear that it's a substring.
                 // Fix the parse tree in situ.
                 return arrElement.ConvertToSubstring();
               }
             }

 // substring -- it looks like a structure component reference of an array
 // slice -- fix the substring and then convert to an intrinsic function
 // call to KIND() or LEN().  And when the designator is a misparsed
 // substring, convert it into a substring reference in place.
 MaybeExpr ExpressionAnalyzer::FixMisparsedSubstring(
     const parser::Designator &d) {
   auto &mutate{const_cast<parser::Designator &>(d)};
   if (auto *dataRef{std::get_if<parser::DataRef>(&mutate.u)}) {
-    if (auto *sc{std::get_if<common::Indirection<parser::StructureComponent>>(
+    if (auto *sc{std::get_if<parser::Indirection<parser::StructureComponent>>(
             &dataRef->u)}) {
       parser::StructureComponent &structComponent{sc->value()};
       parser::CharBlock which{structComponent.component.source};
       if (which == "kind" || which == "len") {
         if (auto substring{
                 FixMisparsedSubstringDataRef(structComponent.base)}) {
           // ...%a(j:k)%kind or %len and "a" is a character scalar
           mutate.u = std::move(*substring);
if (context_.HasError(n.symbol)) { // includes case of no symbol
     const Symbol &ultimate{n.symbol->GetUltimate()};
     if (ultimate.has<semantics::TypeParamDetails>()) {
       // A bare reference to a derived type parameter (within a parameterized
       // derived type definition)
       return Fold(ConvertToType(
           ultimate, AsGenericExpr(TypeParamInquiry{std::nullopt, ultimate})));
     } else {
       if (n.symbol->attrs().test(semantics::Attr::VOLATILE)) {
-        if (const semantics::Scope *pure{semantics::FindPureProcedureContaining(
+        if (const semantics::Scope *
+            pure{semantics::FindPureProcedureContaining(
                 context_.FindScope(n.source))}) {
           SayAt(n,
               "VOLATILE variable '%s' may not be referenced in pure subprogram '%s'"_err_en_US,
               n.source, DEREF(pure->symbol()).name());
           n.symbol->attrs().reset(semantics::Attr::VOLATILE);
         }
       }
       if (!isWholeAssumedSizeArrayOk_ &&
MaybeExpr ExpressionAnalyzer::Analyze(const parser::ArrayElement &ae) {
   {
     auto restorer{AllowWholeAssumedSizeArray()};
     baseExpr = Analyze(ae.base);
   }
   if (baseExpr) {
     if (ae.subscripts.empty()) {
       // will be converted to function call later or error reported
     } else if (baseExpr->Rank() == 0) {
-      if (const Symbol *symbol{GetLastSymbol(*baseExpr)}) {
+      if (const Symbol * symbol{GetLastSymbol(*baseExpr)}) {
         if (!context_.HasError(symbol)) {
           if (inDataStmtConstant_) {
             // Better error for NULL(X) with a MOLD= argument
             Say("'%s' must be an array or structure constructor if used with non-empty parentheses as a DATA statement constant"_err_en_US,
                 symbol->name());
           } else {
             Say("'%s' is not an array"_err_en_US, symbol->name());
           }

 std::optional<Component> ExpressionAnalyzer::CreateComponent(
     DataRef &&base, const Symbol &component, const semantics::Scope &scope) {
   if (IsAllocatableOrPointer(component) && base.Rank() > 0) { // C919b
     Say("An allocatable or pointer component reference must be applied to a scalar base"_err_en_US);
   }
   if (&component.owner() == &scope) {
     return Component{std::move(base), component};
   }
-  if (const Symbol *typeSymbol{scope.GetSymbol()}) {
-    if (const Symbol *parentComponent{typeSymbol->GetParentComponent(&scope)}) {
+  if (const Symbol * typeSymbol{scope.GetSymbol()}) {
+    if (const Symbol *
+        parentComponent{typeSymbol->GetParentComponent(&scope)}) {
       if (const auto *object{
               parentComponent->detailsIf<semantics::ObjectEntityDetails>()}) {
         if (const auto *parentType{object->type()}) {
-          if (const semantics::Scope *parentScope{
-                  parentType->derivedTypeSpec().scope()}) {
+          if (const semantics::Scope *
+              parentScope{parentType->derivedTypeSpec().scope()}) {
             return CreateComponent(
                 DataRef{Component{std::move(base), *parentComponent}},
                 component, *parentScope);
           }
         }
       }
     }
   }

 MaybeExpr ExpressionAnalyzer::Analyze(const parser::CoindexedNamedObject &x) {
   if (auto maybeDataRef{ExtractDataRef(Analyze(x.base))}) {
     DataRef *dataRef{&*maybeDataRef};
     std::vector<Subscript> subscripts;
     SymbolVector reversed;
     if (auto *aRef{std::get_if<ArrayRef>(&dataRef->u)}) {
       subscripts = std::move(aRef->subscript());
       reversed.push_back(aRef->GetLastSymbol());
-      if (Component *component{aRef->base().UnwrapComponent()}) {
+      if (Component * component{aRef->base().UnwrapComponent()}) {
         dataRef = &component->base();
       } else {
         dataRef = nullptr;
       }
     }
     if (dataRef) {
       while (auto *component{std::get_if<Component>(&dataRef->u)}) {
         reversed.push_back(component->GetLastSymbol());
if (!type_) {
     }
   }
 }
 
 void ArrayConstructorContext::Add(const parser::AcValue &x) {
   common::visit(
       common::visitors{
           [&](const parser::AcValue::Triplet &triplet) { Add(triplet); },
-          [&](const common::Indirection<parser::Expr> &expr) {
+          [&](const parser::Indirection<parser::Expr> &expr) {
             Add(expr.value());
           },
-          [&](const common::Indirection<parser::AcImpliedDo> &impliedDo) {
+          [&](const parser::Indirection<parser::AcImpliedDo> &impliedDo) {
             Add(impliedDo.value());
           },
       },
       x.u);
 }
 
 // Transforms l:u(:s) into (_,_=l,u(,s)) with an anonymous index '_'
 void ArrayConstructorContext::Add(const parser::AcValue::Triplet &triplet) {
MaybeExpr ExpressionAnalyzer::Analyze(const parser::ArrayConstructor &array) {
   return acContext.ToExpr();
 }
 
 MaybeExpr ExpressionAnalyzer::Analyze(
     const parser::StructureConstructor &structure) {
   auto &parsedType{std::get<parser::DerivedTypeSpec>(structure.t)};
   parser::Name structureType{std::get<parser::Name>(parsedType.t)};
   parser::CharBlock &typeName{structureType.source};
-  if (semantics::Symbol *typeSymbol{structureType.symbol}) {
+  if (semantics::Symbol * typeSymbol{structureType.symbol}) {
     if (typeSymbol->has<semantics::DerivedTypeDetails>()) {
       semantics::DerivedTypeSpec dtSpec{typeName, typeSymbol->GetUltimate()};
       if (!CheckIsValidForwardReference(dtSpec)) {
         return std::nullopt;
       }
     }
   }
   if (!parsedType.derivedTypeSpec) {
return common::visit(
         }
       },
       proc.details());
 }
 
 static std::optional<int> GetPassIndex(const Symbol &proc) {
   CHECK(!proc.attrs().test(semantics::Attr::NOPASS));
   std::optional<parser::CharBlock> passName{GetPassName(proc)};
-  const auto *interface {
-    semantics::FindInterface(proc)
-  };
+  const auto *interface{semantics::FindInterface(proc)};
   if (!passName || !interface) {
     return 0; // first argument is passed-object
   }
   const auto &subp{interface->get<semantics::SubprogramDetails>()};
   int index{0};
   for (const auto *arg : subp.dummyArgs()) {
     if (arg && arg->name() == passName) {
       return index;
static const Symbol *GetBindingResolution(
   return &binding->symbol();
 }
 
 auto ExpressionAnalyzer::AnalyzeProcedureComponentRef(
     const parser::ProcComponentRef &pcr, ActualArguments &&arguments,
     bool isSubroutine) -> std::optional<CalleeAndArguments> {
   const parser::StructureComponent &sc{pcr.v.thing};
   if (MaybeExpr base{Analyze(sc.base)}) {
-    if (const Symbol *sym{sc.component.symbol}) {
+    if (const Symbol * sym{sc.component.symbol}) {
       if (context_.HasError(sym)) {
         return std::nullopt;
       }
       if (!IsProcedure(*sym)) {
         AttachDeclaration(
             Say(sc.component.source, "'%s' is not a procedure"_err_en_US,
                 sc.component.source),
             *sym);
if (const Symbol * sym{sc.component.symbol}) {
                 Say(sc.component.source,
                     "Base of NOPASS type-bound procedure reference should be scalar"_port_en_US),
                 *sym);
           } else if (IsProcedurePointer(*sym)) { // C919
             Say(sc.component.source,
                 "Base of procedure component reference must be scalar"_err_en_US);
           }
         }
-        if (const Symbol *resolution{
-                GetBindingResolution(dtExpr->GetType(), *sym)}) {
+        if (const Symbol *
+            resolution{GetBindingResolution(dtExpr->GetType(), *sym)}) {
           AddPassArg(arguments, std::move(*dtExpr), *sym, false);
           return CalleeAndArguments{
               ProcedureDesignator{*resolution}, std::move(arguments)};
         } else if (dataRef.has_value()) {
           if (sym->attrs().test(semantics::Attr::NOPASS)) {
             return CalleeAndArguments{
                 ProcedureDesignator{Component{std::move(*dataRef), *sym}},
                 std::move(arguments)};
if (const auto *details{ultimate.detailsIf<semantics::GenericDetails>()}) {
     }
     if (nonElemental) {
       return {&AccessSpecific(symbol, *nonElemental), false};
     } else if (elemental) {
       return {&AccessSpecific(symbol, *elemental), false};
     }
     // Check parent derived type
     if (const auto *parentScope{symbol.owner().GetDerivedTypeParent()}) {
-      if (const Symbol *extended{parentScope->FindComponent(symbol.name())}) {
+      if (const Symbol * extended{parentScope->FindComponent(symbol.name())}) {
         auto pair{ResolveGeneric(
             *extended, actuals, adjustActuals, isSubroutine, false)};
         if (pair.first) {
           return pair;
         }
       }
     }
     if (mightBeStructureConstructor && details->derivedType()) {
       return {details->derivedType(), false};
     }
   }
   // Check for generic or explicit INTRINSIC of the same name in outer scopes.
   // See 15.5.5.2 for details.
   if (!symbol.owner().IsGlobal() && !symbol.owner().IsDerivedType()) {
     for (const std::string &n : GetAllNames(context_, symbol.name())) {
-      if (const Symbol *outer{symbol.owner().parent().FindSymbol(n)}) {
+      if (const Symbol * outer{symbol.owner().parent().FindSymbol(n)}) {
         auto pair{ResolveGeneric(*outer, actuals, adjustActuals, isSubroutine,
             mightBeStructureConstructor)};
         if (pair.first) {
           return pair;
         }
       }
     }
   }
if (scope->sourceRange().Contains(callSite)) {
       }
       AttachDeclaration(msg, proc);
     }
   }
 }
 
 template <typename A> static const Symbol *AssumedTypeDummy(const A &x) {
   if (const auto *designator{
-          std::get_if<common::Indirection<parser::Designator>>(&x.u)}) {
+          std::get_if<parser::Indirection<parser::Designator>>(&x.u)}) {
     if (const auto *dataRef{
             std::get_if<parser::DataRef>(&designator->value().u)}) {
       if (const auto *name{std::get_if<parser::Name>(&dataRef->u)}) {
         return AssumedTypeDummy(*name);
       }
     }
   }
   return nullptr;
 }
 template <>
 const Symbol *AssumedTypeDummy<parser::Name>(const parser::Name &name) {
-  if (const Symbol *symbol{name.symbol}) {
+  if (const Symbol * symbol{name.symbol}) {
     if (const auto *type{symbol->GetType()}) {
       if (type->category() == semantics::DeclTypeSpec::TypeStar) {
         return symbol;
       }
     }
   }
   return nullptr;
 }
if (std::optional<CalleeAndArguments> callee{
       }
       if (!isKernel && !chevrons->empty()) {
         Say("Kernel launch parameters in chevrons may not be used unless calling a kernel subroutine"_err_en_US);
       }
       if (CheckCall(callStmt.source, *proc, callee->arguments)) {
         callStmt.typedCall.Reset(
             new ProcedureRef{std::move(*proc), std::move(callee->arguments),
                 HasAlternateReturns(callee->arguments)},
-            ProcedureRef::Deleter);
+            ProcedureRef::Deleter, ProcedureRef::Copier);
         DEREF(callStmt.typedCall.get()).set_chevrons(std::move(*chevrons));
         return;
       }
     }
     if (!context_.AnyFatalError()) {
       std::string buf;
       llvm::raw_string_ostream dump{buf};
       parser::DumpTree(dump, callStmt);
if (!analyzer.fatalErrors()) {
         }
       }
       assignment.emplace(analyzer.MoveExpr(0), analyzer.MoveExpr(1));
       if (procRef) {
         assignment->u = std::move(*procRef);
       }
     }
     x.typedAssignment.Reset(new GenericAssignmentWrapper{std::move(assignment)},
-        GenericAssignmentWrapper::Deleter);
+        GenericAssignmentWrapper::Deleter, GenericAssignmentWrapper::Copier);
   }
   return common::GetPtrFromOptional(x.typedAssignment->v);
 }
 
 const Assignment *ExpressionAnalyzer::Analyze(
     const parser::PointerAssignmentStmt &x) {
   if (!x.typedAssignment) {
     MaybeExpr lhs{Analyze(std::get<parser::DataRef>(x.t))};
     MaybeExpr rhs;
     {
       auto restorer{AllowNullPointer()};
       rhs = Analyze(std::get<parser::Expr>(x.t));
     }
     if (!lhs || !rhs) {
-      x.typedAssignment.Reset(
-          new GenericAssignmentWrapper{}, GenericAssignmentWrapper::Deleter);
+      x.typedAssignment.Reset(new GenericAssignmentWrapper{},
+          GenericAssignmentWrapper::Deleter, GenericAssignmentWrapper::Copier);
     } else {
       Assignment assignment{std::move(*lhs), std::move(*rhs)};
       common::visit(
           common::visitors{
               [&](const std::list<parser::BoundsRemapping> &list) {
                 Assignment::BoundsRemapping bounds;
                 for (const auto &elem : list) {
                   auto lower{AsSubscript(Analyze(std::get<0>(elem.t)))};
if (!lhs || !rhs) {
                   }
                 }
                 assignment.u = std::move(bounds);
               },
           },
           std::get<parser::PointerAssignmentStmt::Bounds>(x.t).u);
       x.typedAssignment.Reset(
           new GenericAssignmentWrapper{std::move(assignment)},
-          GenericAssignmentWrapper::Deleter);
+          GenericAssignmentWrapper::Deleter, GenericAssignmentWrapper::Copier);
     }
   }
   return common::GetPtrFromOptional(x.typedAssignment->v);
 }
 
 static bool IsExternalCalledImplicitly(
     parser::CharBlock callSite, const ProcedureDesignator &proc) {
   if (const auto *symbol{proc.GetSymbol()}) {
if (const semantics::Scope *
             context_.FindScope(callSite))}) {
       Say(callSite,
           "Procedure '%s' referenced in pure subprogram '%s' must be pure too"_err_en_US,
           procSymbol->name(), DEREF(pure->symbol()).name());
     }
   }
   if (ok && !treatExternalAsImplicit && procSymbol &&
       !(chars && chars->HasExplicitInterface())) {
-    if (const Symbol *global{FindGlobal(*procSymbol)};
+    if (const Symbol * global{FindGlobal(*procSymbol)};
         global && global != procSymbol && IsProcedure(*global)) {
       // Check a known global definition behind a local interface
       if (auto globalChars{characteristics::Procedure::Characterize(
               *global, context_.foldingContext())}) {
         semantics::CheckArguments(*globalChars, arguments, context_,
             context_.FindScope(callSite), true,
             nullptr /*not specific intrinsic*/);
       }
     }
   }
   return chars;
 }
 
 // Unary operations
 
 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::Parentheses &x) {
   if (MaybeExpr operand{Analyze(x.v.value())}) {
-    if (const semantics::Symbol *symbol{GetLastSymbol(*operand)}) {
-      if (const semantics::Symbol *result{FindFunctionResult(*symbol)}) {
+    if (const semantics::Symbol * symbol{GetLastSymbol(*operand)}) {
+      if (const semantics::Symbol * result{FindFunctionResult(*symbol)}) {
         if (semantics::IsProcedurePointer(*result)) {
           Say("A function reference that returns a procedure "
               "pointer may not be parenthesized"_err_en_US); // C1003
         }
       }
     }
     return Parenthesize(std::move(*operand));
   }
MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::NOT &x) {
   return std::nullopt;
 }
 
 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::PercentLoc &x) {
   // Represent %LOC() exactly as if it had been a call to the LOC() extension
   // intrinsic function.
   // Use the actual source for the name of the call for error reporting.
   std::optional<ActualArgument> arg;
-  if (const Symbol *assumedTypeDummy{AssumedTypeDummy(x.v.value())}) {
+  if (const Symbol * assumedTypeDummy{AssumedTypeDummy(x.v.value())}) {
     arg = ActualArgument{ActualArgument::AssumedType{*assumedTypeDummy}};
   } else if (MaybeExpr argExpr{Analyze(x.v.value())}) {
     arg = ActualArgument{std::move(*argExpr)};
   } else {
     return std::nullopt;
   }
   parser::CharBlock at{GetContextualMessages().at()};
   CHECK(at.size() >= 4);
static bool CheckFuncRefToArrayElement(semantics::SemanticsContext &context,
   auto &proc{std::get<parser::ProcedureDesignator>(funcRef.v.t)};
   const auto *name{std::get_if<parser::Name>(&proc.u)};
   if (!name) {
     name = &std::get<parser::ProcComponentRef>(proc.u).v.thing.component;
   }
   if (!name->symbol) {
     return false;
   } else if (name->symbol->Rank() == 0) {
-    if (const Symbol *function{
+    if (const Symbol *
+        function{
             semantics::IsFunctionResultWithSameNameAsFunction(*name->symbol)}) {
       auto &msg{context.Say(funcRef.source,
           function->flags().test(Symbol::Flag::StmtFunction)
               ? "Recursive call to statement function '%s' is not allowed"_err_en_US
               : "Recursive call to '%s' requires a distinct RESULT in its declaration"_err_en_US,
           name->source)};
       AttachDeclaration(&msg, *function);
       name->symbol = const_cast<Symbol *>(function);

 // function call resolution fails.
 template <typename... A>
 static void FixMisparsedFunctionReference(
     semantics::SemanticsContext &context, const std::variant<A...> &constU) {
   // The parse tree is updated in situ when resolving an ambiguous parse.
   using uType = std::decay_t<decltype(constU)>;
   auto &u{const_cast<uType &>(constU)};
   if (auto *func{
-          std::get_if<common::Indirection<parser::FunctionReference>>(&u)}) {
+          std::get_if<parser::Indirection<parser::FunctionReference>>(&u)}) {
     parser::FunctionReference &funcRef{func->value()};
     // Ensure that there are no argument keywords
     for (const auto &arg :
         std::get<std::list<parser::ActualArgSpec>>(funcRef.v.t)) {
       if (std::get<std::optional<parser::Keyword>>(arg.t)) {
         return;
       }
     }
     auto &proc{std::get<parser::ProcedureDesignator>(funcRef.v.t)};
-    if (Symbol *origSymbol{
+    if (Symbol *
+        origSymbol{
             common::visit(common::visitors{
                               [&](parser::Name &name) { return name.symbol; },
                               [&](parser::ProcComponentRef &pcr) {
                                 return pcr.v.thing.component.symbol;
                               },
                           },
                 proc.u)}) {
       Symbol &symbol{origSymbol->GetUltimate()};
       if (symbol.has<semantics::ObjectEntityDetails>() ||
           symbol.has<semantics::AssocEntityDetails>()) {
         // Note that expression in AssocEntityDetails cannot be a procedure
         // pointer as per C1105 so this cannot be a function reference.
-        if constexpr (common::HasMember<common::Indirection<parser::Designator>,
+        if constexpr (common::HasMember<parser::Indirection<parser::Designator>,
                           uType>) {
           if (CheckFuncRefToArrayElement(context, funcRef)) {
-            u = common::Indirection{funcRef.ConvertToArrayElementRef()};
+            u = parser::Indirection<parser::Designator>{
+                funcRef.ConvertToArrayElementRef()};
           }
         } else {
           DIE("can't fix misparsed function as array reference");
         }
       }
     }
   }
 }
MaybeExpr ExpressionAnalyzer::ExprOrVariable(
   if (AssumedTypeDummy(x)) { // C710
     Say("TYPE(*) dummy argument may only be used as an actual argument"_err_en_US);
     ResetExpr(x);
     return std::nullopt;
   }
   MaybeExpr result;
   if constexpr (common::HasMember<parser::StructureConstructor,
                     std::decay_t<decltype(x.u)>> &&
-      common::HasMember<common::Indirection<parser::FunctionReference>,
+      common::HasMember<parser::Indirection<parser::FunctionReference>,
           std::decay_t<decltype(x.u)>>) {
     if (const auto *funcRef{
-            std::get_if<common::Indirection<parser::FunctionReference>>(
+            std::get_if<parser::Indirection<parser::FunctionReference>>(
                 &x.u)}) {
       // Function references in Exprs might turn out to be misparsed structure
       // constructors; we have to try generic procedure resolution
       // first to be sure.
       std::optional<parser::StructureConstructor> ctor;
       result = Analyze(funcRef->value(), &ctor);
       if (result && ctor) {
         // A misparsed function reference is really a structure

 
 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Selector &selector) {
   if (const auto *var{std::get_if<parser::Variable>(&selector.u)}) {
     if (!useSavedTypedExprs_ || !var->typedExpr) {
       parser::CharBlock source{var->GetSource()};
       auto restorer{GetContextualMessages().SetLocation(source)};
       FixMisparsedFunctionReference(context_, var->u);
       if (const auto *funcRef{
-              std::get_if<common::Indirection<parser::FunctionReference>>(
+              std::get_if<parser::Indirection<parser::FunctionReference>>(
                   &var->u)}) {
         // A Selector that parsed as a Variable might turn out during analysis
         // to actually be a structure constructor.  In that case, repair the
         // Variable parse tree node into an Expr
         std::optional<parser::StructureConstructor> ctor;
         if (MaybeExpr result{Analyze(funcRef->value(), &ctor)}) {
           if (ctor) {
             auto &writable{const_cast<parser::Selector &>(selector)};
MaybeExpr ExpressionAnalyzer::MakeFunctionRef(parser::CharBlock callSite,
     ProcedureDesignator &&proc, ActualArguments &&arguments) {
   if (const auto *intrinsic{std::get_if<SpecificIntrinsic>(&proc.u)}) {
     if (intrinsic->characteristics.value().attrs.test(
             characteristics::Procedure::Attr::NullPointer) &&
         arguments.empty()) {
       return Expr<SomeType>{NullPointer{}};
     }
   }
-  if (const Symbol *symbol{proc.GetSymbol()}) {
+  if (const Symbol * symbol{proc.GetSymbol()}) {
     if (!ResolveForward(*symbol)) {
       return std::nullopt;
     }
   }
   if (auto chars{CheckCall(callSite, proc, arguments)}) {
     if (chars->functionResult) {
       const auto &result{*chars->functionResult};
       ProcedureRef procRef{std::move(proc), std::move(arguments)};
void ArgumentAnalyzer::Analyze(const parser::Variable &x) {
   fatalErrors_ = true;
 }
 
 void ArgumentAnalyzer::Analyze(
     const parser::ActualArgSpec &arg, bool isSubroutine) {
   // TODO: C1534: Don't allow a "restricted" specific intrinsic to be passed.
   std::optional<ActualArgument> actual;
   common::visit(common::visitors{
-                    [&](const common::Indirection<parser::Expr> &x) {
+                    [&](const parser::Indirection<parser::Expr> &x) {
                       actual = AnalyzeExpr(x.value());
                       SetArgSourceLocation(actual, x.value().source);
                     },
                     [&](const parser::AltReturnSpec &label) {
                       if (!isSubroutine) {
                         context_.Say(
                             "alternate return specification may not appear on"
                             " function reference"_err_en_US);
MaybeExpr ArgumentAnalyzer::TryDefinedOp(
   std::string oprNameString{
       isUserOp ? std::string{opr} : "operator("s + opr + ')'};
   parser::CharBlock oprName{oprNameString};
   parser::Messages hitBuffer;
   {
     parser::Messages buffer;
     auto restorer{context_.GetContextualMessages().SetMessages(buffer)};
     const auto &scope{context_.context().FindScope(source_)};
-    if (Symbol *symbol{scope.FindSymbol(oprName)}) {
+    if (Symbol * symbol{scope.FindSymbol(oprName)}) {
       anyPossibilities = true;
       parser::Name name{symbol->name(), symbol};
       result = context_.AnalyzeDefinedOp(name, GetActuals());
       if (result) {
         inaccessible = CheckAccessibleSymbol(scope, *symbol);
         if (inaccessible) {
           result.reset();
         } else {
           hit.push_back(symbol);
           hitBuffer = std::move(buffer);
         }
       }
     }
     for (std::size_t passIndex{0}; passIndex < actuals_.size(); ++passIndex) {
       buffer.clear();
       const Symbol *generic{nullptr};
-      if (const Symbol *binding{
-              FindBoundOp(oprName, passIndex, generic, false)}) {
+      if (const Symbol *
+          binding{FindBoundOp(oprName, passIndex, generic, false)}) {
         anyPossibilities = true;
         if (MaybeExpr thisResult{TryBoundOp(*binding, passIndex)}) {
           if (auto thisInaccessible{
                   CheckAccessibleSymbol(scope, DEREF(generic))}) {
             inaccessible = thisInaccessible;
           } else {
             result = std::move(thisResult);
             hit.push_back(binding);
std::optional<ProcedureRef> ArgumentAnalyzer::GetDefinedAssignmentProc() {
   std::optional<int> passedObjectIndex;
   std::string oprNameString{"assignment(=)"};
   parser::CharBlock oprName{oprNameString};
   const auto &scope{context_.context().FindScope(source_)};
   // If multiple resolutions were possible, they will have been already
   // diagnosed.
   {
     auto restorer{context_.GetContextualMessages().DiscardMessages()};
-    if (const Symbol *symbol{scope.FindSymbol(oprName)}) {
+    if (const Symbol * symbol{scope.FindSymbol(oprName)}) {
       ExpressionAnalyzer::AdjustActuals noAdjustment;
       proc =
           context_.ResolveGeneric(*symbol, actuals_, noAdjustment, true).first;
     }
     for (std::size_t i{0}; !proc && i < actuals_.size(); ++i) {
       const Symbol *generic{nullptr};
-      if (const Symbol *binding{FindBoundOp(oprName, i, generic, true)}) {
+      if (const Symbol * binding{FindBoundOp(oprName, i, generic, true)}) {
         if (CheckAccessibleSymbol(scope, DEREF(generic))) {
           // ignore inaccessible type-bound ASSIGNMENT(=) generic
         } else if (const Symbol *
             resolution{GetBindingResolution(GetType(i), *binding)}) {
           proc = resolution;
         } else {
           proc = binding;
           passedObjectIndex = i;

 }
 
 void ArgumentAnalyzer::Dump(llvm::raw_ostream &os) {
   os << "source_: " << source_.ToString() << " fatalErrors_ = " << fatalErrors_
      << '\n';
   for (const auto &actual : actuals_) {
     if (!actual.has_value()) {
       os << "- error\n";
-    } else if (const Symbol *symbol{actual->GetAssumedTypeDummy()}) {
+    } else if (const Symbol * symbol{actual->GetAssumedTypeDummy()}) {
       os << "- assumed type: " << symbol->name().ToString() << '\n';
     } else if (const Expr<SomeType> *expr{actual->UnwrapExpr()}) {
       expr->AsFortran(os << "- expr: ") << '\n';
     } else {
       DIE("bad ActualArgument");
     }
   }
 }
 
 std::optional<ActualArgument> ArgumentAnalyzer::AnalyzeExpr(
     const parser::Expr &expr) {
   source_.ExtendToCover(expr.source);
-  if (const Symbol *assumedTypeDummy{AssumedTypeDummy(expr)}) {
+  if (const Symbol * assumedTypeDummy{AssumedTypeDummy(expr)}) {
     ResetExpr(expr);
     if (isProcedureCall_) {
       ActualArgument arg{ActualArgument::AssumedType{*assumedTypeDummy}};
       SetArgSourceLocation(arg, expr.source);
       return std::move(arg);
     }
     context_.SayAt(expr.source,
         "TYPE(*) dummy argument may only be used as an actual argument"_err_en_US);
const Symbol *ArgumentAnalyzer::FindBoundOp(parser::CharBlock oprName,
   generic = scope ? scope->FindComponent(oprName) : nullptr;
   if (generic) {
     ExpressionAnalyzer::AdjustActuals adjustment{
         [&](const Symbol &proc, ActualArguments &) {
           return passIndex == GetPassIndex(proc).value_or(-1);
         }};
     auto pair{
         context_.ResolveGeneric(*generic, actuals_, adjustment, isSubroutine)};
-    if (const Symbol *binding{pair.first}) {
+    if (const Symbol * binding{pair.first}) {
       CHECK(binding->has<semantics::ProcBindingDetails>());
       // Use the most recent override of the binding, if any
       return scope->FindComponent(binding->name());
     } else {
       context_.EmitGenericResolutionError(*generic, pair.second, isSubroutine);
     }
   }
   return nullptr;

flang/lib/Semantics/mod-file.cpp

 }
 
 // program was read from a .mod file for a submodule; return the name of the
 // submodule's parent submodule, nullptr if none.
 static std::optional<SourceName> GetSubmoduleParent(
     const parser::Program &program) {
   CHECK(program.v.size() == 1);
   auto &unit{program.v.front()};
-  auto &submod{std::get<common::Indirection<parser::Submodule>>(unit.u)};
+  auto &submod{std::get<parser::Indirection<parser::Submodule>>(unit.u)};
   auto &stmt{
       std::get<parser::Statement<parser::SubmoduleStmt>>(submod.value().t)};
   auto &parentId{std::get<parser::ParentIdentifier>(stmt.statement.t)};
   if (auto &parent{std::get<std::optional<parser::Name>>(parentId.t)}) {
     return parent->source;
   } else {
     return std::nullopt;
   }
if (const auto *useDetails{symbol.detailsIf<UseDetails>()}) {
       if (const auto *generic{ultimate.detailsIf<GenericDetails>()}) {
         // The generic may not be needed itself, but the specific procedure
         // &/or derived type that it shadows may be needed.
         const Symbol *spec{generic->specific()};
         const Symbol *dt{generic->derivedType()};
         needed = needed || (spec && useSet_.count(*spec) > 0) ||
             (dt && useSet_.count(*dt) > 0);
       } else if (const auto *subp{ultimate.detailsIf<SubprogramDetails>()}) {
-        const Symbol *interface { subp->moduleInterface() };
+        const Symbol *interface{subp->moduleInterface()};
         needed = needed || (interface && useSet_.count(*interface) > 0);
       }
       if (needed) {
         need_.push_back(symbol);
       }
     } else if (symbol.has<SubprogramDetails>()) {
       // An internal subprogram is needed if it is used as interface
       // for a dummy or return value procedure.
if (!isInterface_) {
     return false;
   } else if (IsSeparateModuleProcedureInterface(&symbol_)) {
     return false; // IMPORT needed only for external and dummy procedure
                   // interfaces
   } else if (&symbol == scope_.symbol()) {
     return false;
   } else if (symbol.owner().Contains(scope_)) {
     return true;
-  } else if (const Symbol *found{scope_.FindSymbol(name)}) {
+  } else if (const Symbol * found{scope_.FindSymbol(name)}) {
     // detect import from ancestor of use-associated symbol
     return found->has<UseDetails>() && found->owner() != scope_;
   } else {
     // "found" can be null in the case of a use-associated derived type's parent
     // type
     CHECK(symbol.has<DerivedTypeDetails>());
     return false;
   }
 }
 
 } // namespace Fortran::semantics

flang/lib/Semantics/program-tree.cpp

 
 namespace Fortran::semantics {
 
 static void GetEntryStmts(
     ProgramTree &node, const parser::SpecificationPart &spec) {
   const auto &implicitPart{std::get<parser::ImplicitPart>(spec.t)};
   for (const parser::ImplicitPartStmt &stmt : implicitPart.v) {
     if (const auto *entryStmt{std::get_if<
-            parser::Statement<common::Indirection<parser::EntryStmt>>>(
+            parser::Statement<parser::Indirection<parser::EntryStmt>>>(
             &stmt.u)}) {
       node.AddEntry(entryStmt->statement.value());
     }
   }
   for (const auto &decl :
       std::get<std::list<parser::DeclarationConstruct>>(spec.t)) {
     if (const auto *entryStmt{std::get_if<
-            parser::Statement<common::Indirection<parser::EntryStmt>>>(
+            parser::Statement<parser::Indirection<parser::EntryStmt>>>(
             &decl.u)}) {
       node.AddEntry(entryStmt->statement.value());
     }
   }
 }
 
 static void GetEntryStmts(
     ProgramTree &node, const parser::ExecutionPart &exec) {
   for (const auto &epConstruct : exec.v) {
     if (const auto *entryStmt{std::get_if<
-            parser::Statement<common::Indirection<parser::EntryStmt>>>(
+            parser::Statement<parser::Indirection<parser::EntryStmt>>>(
             &epConstruct.u)}) {
       node.AddEntry(entryStmt->statement.value());
     }
   }
 }
 
 // Collects generics that define simple names that could include
 // identically-named subprograms as specific procedures.
 static void GetGenerics(
     ProgramTree &node, const parser::SpecificationPart &spec) {
   for (const auto &decl :
       std::get<std::list<parser::DeclarationConstruct>>(spec.t)) {
     if (const auto *spec{
             std::get_if<parser::SpecificationConstruct>(&decl.u)}) {
       if (const auto *generic{std::get_if<
-              parser::Statement<common::Indirection<parser::GenericStmt>>>(
+              parser::Statement<parser::Indirection<parser::GenericStmt>>>(
               &spec->u)}) {
         const parser::GenericStmt &genericStmt{generic->statement.value()};
         const auto &genericSpec{std::get<parser::GenericSpec>(genericStmt.t)};
         node.AddGeneric(genericSpec);
       } else if (const auto *interface{
-                     std::get_if<common::Indirection<parser::InterfaceBlock>>(
+                     std::get_if<parser::Indirection<parser::InterfaceBlock>>(
                          &spec->u)}) {
         const parser::InterfaceBlock &interfaceBlock{interface->value()};
         const parser::InterfaceStmt &interfaceStmt{
             std::get<parser::Statement<parser::InterfaceStmt>>(interfaceBlock.t)
                 .statement};
         const auto *genericSpec{
             std::get_if<std::optional<parser::GenericSpec>>(&interfaceStmt.u)};
         if (genericSpec && genericSpec->has_value()) {

flang/lib/Semantics/resolve-labels.cpp

 using SourceStmtList = std::vector<SourceStatementInfoTuplePOD>;
 enum class Legality { never, always, formerly };
 
 bool HasScope(ProxyForScope scope) { return scope != ProxyForScope{0u}; }
 
 // F18:R1131
 template <typename A>
 constexpr Legality IsLegalDoTerm(const parser::Statement<A> &) {
-  if (std::is_same_v<A, common::Indirection<parser::EndDoStmt>> ||
+  if (std::is_same_v<A, parser::Indirection<parser::EndDoStmt>> ||
       std::is_same_v<A, parser::EndDoStmt>) {
     return Legality::always;
   } else if (std::is_same_v<A, parser::EndForallStmt> ||
       std::is_same_v<A, parser::EndWhereStmt>) {
     // Executable construct end statements are also supported as
     // an extension but they need special care because the associated
     // construct create their own scope.
     return Legality::formerly;
   } else {
     return Legality::never;
   }
 }
 
 constexpr Legality IsLegalDoTerm(
     const parser::Statement<parser::ActionStmt> &actionStmt) {
   if (std::holds_alternative<parser::ContinueStmt>(actionStmt.statement.u)) {
     // See F08:C816
     return Legality::always;
   } else if (!(std::holds_alternative<
-                   common::Indirection<parser::ArithmeticIfStmt>>(
+                   parser::Indirection<parser::ArithmeticIfStmt>>(
                    actionStmt.statement.u) ||
-                 std::holds_alternative<common::Indirection<parser::CycleStmt>>(
+                 std::holds_alternative<parser::Indirection<parser::CycleStmt>>(
                      actionStmt.statement.u) ||
-                 std::holds_alternative<common::Indirection<parser::ExitStmt>>(
+                 std::holds_alternative<parser::Indirection<parser::ExitStmt>>(
                      actionStmt.statement.u) ||
-                 std::holds_alternative<common::Indirection<parser::StopStmt>>(
+                 std::holds_alternative<parser::Indirection<parser::StopStmt>>(
                      actionStmt.statement.u) ||
-                 std::holds_alternative<common::Indirection<parser::GotoStmt>>(
+                 std::holds_alternative<parser::Indirection<parser::GotoStmt>>(
                      actionStmt.statement.u) ||
                  std::holds_alternative<
-                     common::Indirection<parser::ReturnStmt>>(
+                     parser::Indirection<parser::ReturnStmt>>(
                      actionStmt.statement.u))) {
     return Legality::formerly;
   } else {
     return Legality::never;
   }
 }
 
 template <typename A> constexpr bool IsFormat(const parser::Statement<A> &) {
-  return std::is_same_v<A, common::Indirection<parser::FormatStmt>>;
+  return std::is_same_v<A, parser::Indirection<parser::FormatStmt>>;
 }
 
 template <typename A>
 constexpr Legality IsLegalBranchTarget(const parser::Statement<A> &) {
   if (std::is_same_v<A, parser::ActionStmt> ||
       std::is_same_v<A, parser::AssociateStmt> ||
       std::is_same_v<A, parser::EndAssociateStmt> ||
       std::is_same_v<A, parser::IfThenStmt> ||
       std::is_same_v<A, parser::EndIfStmt> ||
       std::is_same_v<A, parser::SelectCaseStmt> ||
       std::is_same_v<A, parser::EndSelectStmt> ||
       std::is_same_v<A, parser::SelectRankStmt> ||
       std::is_same_v<A, parser::SelectTypeStmt> ||
-      std::is_same_v<A, common::Indirection<parser::LabelDoStmt>> ||
+      std::is_same_v<A, parser::Indirection<parser::LabelDoStmt>> ||
       std::is_same_v<A, parser::NonLabelDoStmt> ||
       std::is_same_v<A, parser::EndDoStmt> ||
-      std::is_same_v<A, common::Indirection<parser::EndDoStmt>> ||
+      std::is_same_v<A, parser::Indirection<parser::EndDoStmt>> ||
       std::is_same_v<A, parser::BlockStmt> ||
       std::is_same_v<A, parser::EndBlockStmt> ||
       std::is_same_v<A, parser::CriticalStmt> ||
       std::is_same_v<A, parser::EndCriticalStmt> ||
       std::is_same_v<A, parser::ForallConstructStmt> ||
       std::is_same_v<A, parser::WhereConstructStmt> ||
       std::is_same_v<A, parser::EndFunctionStmt> ||
       std::is_same_v<A, parser::EndMpSubprogramStmt> ||

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

return common::visit(
       designator.u);
 }
 
 bool EquivalenceSets::CheckDataRef(
     const parser::CharBlock &source, const parser::DataRef &x) {
   return common::visit(
       common::visitors{
           [&](const parser::Name &name) { return CheckObject(name); },
-          [&](const common::Indirection<parser::StructureComponent> &) {
+          [&](const parser::Indirection<parser::StructureComponent> &) {
             context_.Say(source, // C8107
                 "Derived type component '%s' is not allowed in an equivalence set"_err_en_US,
                 source);
             return false;
           },
-          [&](const common::Indirection<parser::ArrayElement> &elem) {
+          [&](const parser::Indirection<parser::ArrayElement> &elem) {
             bool ok{CheckDataRef(source, elem.value().base)};
             for (const auto &subscript : elem.value().subscripts) {
               ok &= common::visit(
                   common::visitors{
                       [&](const parser::SubscriptTriplet &) {
                         context_.Say(source, // C924, R872
                             "Array section '%s' is not allowed in an equivalence set"_err_en_US,
                             source);
                         return false;
                       },
                       [&](const parser::IntExpr &y) {
                         return CheckArrayBound(y.thing.value());
                       },
                   },
                   subscript.u);
             }
             return ok;
           },
-          [&](const common::Indirection<parser::CoindexedNamedObject> &) {
+          [&](const parser::Indirection<parser::CoindexedNamedObject> &) {
             context_.Say(source, // C924 (R872)
                 "Coindexed object '%s' is not allowed in an equivalence set"_err_en_US,
                 source);
             return false;
           },
       },
       x.u);
 }

 
 class SymbolMapper : public evaluate::AnyTraverse<SymbolMapper, bool> {
 public:
   using Base = evaluate::AnyTraverse<SymbolMapper, bool>;
   SymbolMapper(Scope &scope, SymbolAndTypeMappings &map)
       : Base{*this}, scope_{scope}, map_{map} {}
   using Base::operator();
   bool operator()(const SymbolRef &ref) const {
-    if (const Symbol *mapped{MapSymbol(*ref)}) {
+    if (const Symbol * mapped{MapSymbol(*ref)}) {
       const_cast<SymbolRef &>(ref) = *mapped;
     }
     return false;
   }
   bool operator()(const Symbol &x) const {
     if (MapSymbol(x)) {
       DIE("SymbolMapper hit symbol outside SymbolRef");
     }
private:
   const Symbol *MapInterface(const Symbol *);
 
   Scope &scope_;
   SymbolAndTypeMappings &map_;
 };
 
 void SymbolMapper::MapSymbolExprs(Symbol &symbol) {
   if (auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
-    if (const DeclTypeSpec *type{object->type()}) {
-      if (const DeclTypeSpec *newType{MapType(*type)}) {
+    if (const DeclTypeSpec * type{object->type()}) {
+      if (const DeclTypeSpec * newType{MapType(*type)}) {
         object->ReplaceType(*newType);
       }
     }
   }
   common::visit(
       common::visitors{[&](ObjectEntityDetails &object) {
                          for (ShapeSpec &spec : object.shape()) {
                            MapShapeSpec(spec);
const DeclTypeSpec *SymbolMapper::MapType(const DeclTypeSpec &type) {
   if (type.category() == DeclTypeSpec::Category::Character) {
     const CharacterTypeSpec &charType{type.characterTypeSpec()};
     if (charType.length().GetExplicit()) {
       ParamValue newLen{charType.length()};
       (*this)(newLen.GetExplicit());
       newType = &scope_.MakeCharacterType(
           std::move(newLen), KindExpr{charType.kind()});
     }
-  } else if (const DerivedTypeSpec *derived{type.AsDerived()}) {
+  } else if (const DerivedTypeSpec * derived{type.AsDerived()}) {
     if (!derived->parameters().empty()) {
       DerivedTypeSpec newDerived{derived->name(), derived->typeSymbol()};
       newDerived.CookParameters(scope_.context().foldingContext());
       for (const auto &[paramName, paramValue] : derived->parameters()) {
         ParamValue newParamValue{paramValue};
         MapParamValue(newParamValue);
         newDerived.AddParamValue(paramName, std::move(newParamValue));
       }
       // Scope::InstantiateDerivedTypes() instantiates it later.
       newType = &scope_.MakeDerivedType(type.category(), std::move(newDerived));
     }
   }
   if (newType) {
     map_.typeMap[&type] = newType;
   }
   return newType;
 }
 
 const DeclTypeSpec *SymbolMapper::MapType(const DeclTypeSpec *type) {
   return type ? MapType(*type) : nullptr;
 }
 
 const Symbol *SymbolMapper::MapInterface(const Symbol *interface) {
-  if (const Symbol *mapped{MapSymbol(interface)}) {
+  if (const Symbol * mapped{MapSymbol(interface)}) {
     return mapped;
   }
   if (interface) {
     if (&interface->owner() != &scope_) {
       return interface;
     } else if (const auto *subp{interface->detailsIf<SubprogramDetails>()};
                subp && subp->isInterface()) {
-      if (Symbol *newSymbol{scope_.CopySymbol(*interface)}) {
+      if (Symbol * newSymbol{scope_.CopySymbol(*interface)}) {
         newSymbol->get<SubprogramDetails>().set_isInterface(true);
         map_.symbolMap[interface] = newSymbol;
         Scope &newScope{scope_.MakeScope(Scope::Kind::Subprogram, newSymbol)};
         MapSubprogramToNewSymbols(*interface, *newSymbol, newScope, &map_);
         return newSymbol;
       }
     }
   }
   return nullptr;
 }
 
 void MapSubprogramToNewSymbols(const Symbol &oldSymbol, Symbol &newSymbol,
     Scope &newScope, SymbolAndTypeMappings *mappings) {
   SymbolAndTypeMappings newMappings;
   if (!mappings) {
     mappings = &newMappings;
   }
   mappings->symbolMap[&oldSymbol] = &newSymbol;
   const auto &oldDetails{oldSymbol.get<SubprogramDetails>()};
   auto &newDetails{newSymbol.get<SubprogramDetails>()};
   for (const Symbol *dummyArg : oldDetails.dummyArgs()) {
     if (!dummyArg) {
       newDetails.add_alternateReturn();
-    } else if (Symbol *copy{newScope.CopySymbol(*dummyArg)}) {
+    } else if (Symbol * copy{newScope.CopySymbol(*dummyArg)}) {
       newDetails.add_dummyArg(*copy);
       mappings->symbolMap[dummyArg] = copy;
     }
   }
   if (oldDetails.isFunction()) {
     newScope.erase(newSymbol.name());
-    if (Symbol *copy{newScope.CopySymbol(oldDetails.result())}) {
+    if (Symbol * copy{newScope.CopySymbol(oldDetails.result())}) {
       newDetails.set_result(*copy);
       mappings->symbolMap[&oldDetails.result()] = copy;
     }
   }
   SymbolMapper mapper{newScope, *mappings};
   for (auto &[_, ref] : newScope) {
     mapper.MapSymbolExprs(*ref);
   }
   newScope.InstantiateDerivedTypes();
 }
 
 } // namespace Fortran::semantics

flang/lib/Semantics/resolve-names.cpp

 #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/Common/visit.h"
 #include "flang/Evaluate/characteristics.h"
 #include "flang/Evaluate/check-expression.h"
 #include "flang/Evaluate/common.h"
 #include "flang/Evaluate/fold-designator.h"
 #include "flang/Evaluate/fold.h"
 #include "flang/Evaluate/intrinsics.h"

 #include <map>
 #include <set>
 #include <stack>
 
 namespace Fortran::semantics {
 
 using namespace parser::literals;
 
-template <typename T> using Indirection = common::Indirection<T>;
+template <typename T> using Indirection = parser::Indirection<T>;
 using Message = parser::Message;
 using Messages = parser::Messages;
 using MessageFixedText = parser::MessageFixedText;
 using MessageFormattedText = parser::MessageFormattedText;
 
 class ResolveNamesVisitor;
 class ScopeHandler;
 
for (auto &pair : currScope()) {
     }
     if (!symbol.has<HostAssocDetails>()) {
       CheckPossibleBadForwardRef(symbol);
     }
   }
   currScope().InstantiateDerivedTypes();
   for (const auto &decl : decls) {
     if (const auto *statement{std::get_if<
-            parser::Statement<common::Indirection<parser::StmtFunctionStmt>>>(
+            parser::Statement<parser::Indirection<parser::StmtFunctionStmt>>>(
             &decl.u)}) {
       AnalyzeStmtFunctionStmt(statement->statement.value());
     }
   }
   // TODO: what about instantiations in BLOCK?
   CheckSaveStmts();
   CheckCommonBlocks();
   if (!inInterfaceBlock()) {
if (tkr->empty()) {
       }
     }
   } else {
     Say(x.source, "Compiler directive was ignored"_warn_en_US);
   }
 }
 
 bool ResolveNamesVisitor::Pre(const parser::ProgramUnit &x) {
-  if (std::holds_alternative<common::Indirection<parser::CompilerDirective>>(
+  if (std::holds_alternative<parser::Indirection<parser::CompilerDirective>>(
           x.u)) {
     // TODO: global directives
     return true;
   }
   auto root{ProgramTree::Build(x)};
   SetScope(topScope_);
   ResolveSpecificationParts(root);
   FinishSpecificationParts(root);
   ResolveExecutionParts(root);
   ResolveAccParts(context(), x);
   ResolveOmpParts(context(), x);
   return false;
 }
 
 template <typename A> std::set<SourceName> GetUses(const A &x) {
   std::set<SourceName> uses;
   if constexpr (!std::is_same_v<A, parser::CompilerDirective>) {
     const auto &spec{std::get<parser::SpecificationPart>(x.t)};
     const auto &unitUses{std::get<
-        std::list<parser::Statement<common::Indirection<parser::UseStmt>>>>(
+        std::list<parser::Statement<parser::Indirection<parser::UseStmt>>>>(
         spec.t)};
     for (const auto &u : unitUses) {
       uses.insert(u.statement.value().moduleName.source);
     }
   }
   return uses;
 }
 
 bool ResolveNamesVisitor::Pre(const parser::Program &x) {
   std::map<SourceName, const parser::ProgramUnit *> modules;
   std::set<SourceName> uses;
   bool disordered{false};
   for (const auto &progUnit : x.v) {
     if (const auto *indMod{
-            std::get_if<common::Indirection<parser::Module>>(&progUnit.u)}) {
+            std::get_if<parser::Indirection<parser::Module>>(&progUnit.u)}) {
       const parser::Module &mod{indMod->value()};
       const auto &moduleStmt{
           std::get<parser::Statement<parser::ModuleStmt>>(mod.t)};
       const SourceName &name{moduleStmt.statement.v.source};
       if (auto iter{modules.find(name)}; iter != modules.end()) {
         Say(name,
             "Module '%s' appears multiple times in a compilation unit"_err_en_US)
             .Attach(iter->first, "First definition of module"_en_US);
bool ResolveNamesVisitor::Pre(const parser::Program &x) {
   // Process modules in topological order
   std::vector<const parser::ProgramUnit *> moduleOrder;
   while (!modules.empty()) {
     bool ok;
     for (const auto &pair : modules) {
       const SourceName &name{pair.first};
       const parser::ProgramUnit &progUnit{*pair.second};
       const parser::Module &m{
-          std::get<common::Indirection<parser::Module>>(progUnit.u).value()};
+          std::get<parser::Indirection<parser::Module>>(progUnit.u).value()};
       ok = true;
       for (const SourceName &use : GetUses(m)) {
         if (modules.find(use) != modules.end()) {
           ok = false;
           break;
         }
       }
       if (ok) {
while (!modules.empty()) {
     }
   }
   // Modules can be ordered.  Process them first, and then all of the other
   // program units.
   for (const parser::ProgramUnit *progUnit : moduleOrder) {
     Walk(*progUnit);
   }
   for (const auto &progUnit : x.v) {
-    if (!std::get_if<common::Indirection<parser::Module>>(&progUnit.u)) {
+    if (!std::get_if<parser::Indirection<parser::Module>>(&progUnit.u)) {
       Walk(progUnit);
     }
   }
   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.

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

public:
   bool Pre(parser::EndMpSubprogramStmt &) { return false; }
   bool Pre(parser::EndProgramStmt &) { return false; }
   bool Pre(parser::EndSubmoduleStmt &) { return false; }
   bool Pre(parser::EndSubroutineStmt &) { return false; }
   bool Pre(parser::EndTypeStmt &) { return false; }
 
 private:
   using stmtFuncType =
-      parser::Statement<common::Indirection<parser::StmtFunctionStmt>>;
+      parser::Statement<parser::Indirection<parser::StmtFunctionStmt>>;
   bool errorOnUnresolvedName_{true};
   parser::Messages &messages_;
   std::list<stmtFuncType> stmtFuncsToConvert_;
 };
 
 // Check that name has been resolved to a symbol
 void RewriteMutator::Post(parser::Name &name) {
   if (!name.symbol && errorOnUnresolvedName_) {

flang/lib/Semantics/semantics.cpp

parser::Program &SemanticsContext::SaveParseTree(parser::Program &&tree) {
   return modFileParseTrees_.emplace_back(std::move(tree));
 }
 
 bool Semantics::Perform() {
   // Implicitly USE the __Fortran_builtins module so that special types
   // (e.g., __builtin_team_type) are available to semantics, esp. for
   // intrinsic checking.
   if (!program_.v.empty()) {
-    const auto *frontModule{std::get_if<common::Indirection<parser::Module>>(
+    const auto *frontModule{std::get_if<parser::Indirection<parser::Module>>(
         &program_.v.front().u)};
     if (frontModule &&
         (std::get<parser::Statement<parser::ModuleStmt>>(frontModule->value().t)
                     .statement.v.source == "__fortran_builtins" ||
             std::get<parser::Statement<parser::ModuleStmt>>(
                 frontModule->value().t)
                     .statement.v.source == "__ppc_types")) {
       // Don't try to read the builtins module when we're actually building it.

flang/lib/Semantics/tools.cpp

const evaluate::Assignment *GetAssignment(
   return x.typedAssignment ? common::GetPtrFromOptional(x.typedAssignment->v)
                            : nullptr;
 }
 
 const Symbol *FindInterface(const Symbol &symbol) {
   return common::visit(
       common::visitors{
           [](const ProcEntityDetails &details) {
-            const Symbol *interface {
-              details.procInterface()
-            };
+            const Symbol *interface{details.procInterface()};
             return interface ? FindInterface(*interface) : nullptr;
           },
           [](const ProcBindingDetails &details) {
             return FindInterface(details.symbol());
           },
           [&](const SubprogramDetails &) { return &symbol; },
           [](const UseDetails &details) {
             return FindInterface(details.symbol());
using ImageControlStmts =
           parser::EventPostStmt, parser::EventWaitStmt, parser::FormTeamStmt,
           parser::LockStmt, parser::SyncAllStmt, parser::SyncImagesStmt,
           parser::SyncMemoryStmt, parser::SyncTeamStmt, parser::UnlockStmt>;
 
 public:
   template <typename T> bool operator()(const T &) {
     return common::HasMember<T, ImageControlStmts>;
   }
-  template <typename T> bool operator()(const common::Indirection<T> &x) {
+  template <typename T, bool COPY>
+  bool operator()(const common::Indirection<T, COPY> &x) {
     return (*this)(x.value());
   }
   template <typename A> bool operator()(const parser::Statement<A> &x) {
     return (*this)(x.statement);
   }
   bool operator()(const parser::AllocateStmt &stmt) {
     const auto &allocationList{std::get<std::list<parser::Allocation>>(stmt.t)};
     for (const auto &allocation : allocationList) {
if (auto *name{std::get_if<parser::Name>(&procedureDesignator.u)}) {
       // TODO: also ensure that the procedure is, in fact, an intrinsic
       if (name->source == "move_alloc") {
         const auto &args{
             std::get<std::list<parser::ActualArgSpec>>(stmt.call.t)};
         if (!args.empty()) {
           const parser::ActualArg &actualArg{
               std::get<parser::ActualArg>(args.front().t)};
           if (const auto *argExpr{
-                  std::get_if<common::Indirection<parser::Expr>>(
+                  std::get_if<parser::Indirection<parser::Expr>>(
                       &actualArg.u)}) {
             return HasCoarray(argExpr->value());
           }
         }
       }
     }
     return false;
   }

 }
 
 std::optional<parser::MessageFixedText> GetImageControlStmtCoarrayMsg(
     const parser::ExecutableConstruct &construct) {
   if (const auto *actionStmt{
           std::get_if<parser::Statement<parser::ActionStmt>>(&construct.u)}) {
     return common::visit(
         common::visitors{
-            [](const common::Indirection<parser::AllocateStmt> &)
+            [](const parser::Indirection<parser::AllocateStmt> &)
                 -> std::optional<parser::MessageFixedText> {
               return "ALLOCATE of a coarray is an image control"
                      " statement"_en_US;
             },
-            [](const common::Indirection<parser::DeallocateStmt> &)
+            [](const parser::Indirection<parser::DeallocateStmt> &)
                 -> std::optional<parser::MessageFixedText> {
               return "DEALLOCATE of a coarray is an image control"
                      " statement"_en_US;
             },
-            [](const common::Indirection<parser::CallStmt> &)
+            [](const parser::Indirection<parser::CallStmt> &)
                 -> std::optional<parser::MessageFixedText> {
               return "MOVE_ALLOC of a coarray is an image control"
                      " statement "_en_US;
             },
             [](const auto &) -> std::optional<parser::MessageFixedText> {
               return std::nullopt;
             },
         },
         actionStmt->statement.u);
   }
   return std::nullopt;
 }
 
 parser::CharBlock GetImageControlStmtLocation(
     const parser::ExecutableConstruct &executableConstruct) {
   return common::visit(
       common::visitors{
-          [](const common::Indirection<parser::ChangeTeamConstruct>
+          [](const parser::Indirection<parser::ChangeTeamConstruct>
                   &construct) {
             return std::get<parser::Statement<parser::ChangeTeamStmt>>(
                 construct.value().t)
                 .source;
           },
-          [](const common::Indirection<parser::CriticalConstruct> &construct) {
+          [](const parser::Indirection<parser::CriticalConstruct> &construct) {
             return std::get<parser::Statement<parser::CriticalStmt>>(
                 construct.value().t)
                 .source;
           },
           [](const parser::Statement<parser::ActionStmt> &actionStmt) {
             return actionStmt.source;
           },
           [](const auto &) { return parser::CharBlock{}; },

flang/tools/f18-parse-demo/stub-evaluate.cpp

 //===-- tools/f18/stub-evaluate.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
 //
 //===----------------------------------------------------------------------===//
 
 // The parse tree has slots in which pointers to the results of semantic
 // analysis may be placed.  When using the parser without the semantics
 // libraries, as here, we need to stub out the dependences on the external
-// deleters, which will never actually be called.
+// deleters and copiers, which will never actually be called.
 
 namespace Fortran::evaluate {
 struct GenericExprWrapper {
   static void Deleter(GenericExprWrapper *);
+  static GenericExprWrapper *Copier(GenericExprWrapper *);
 };
 void GenericExprWrapper::Deleter(GenericExprWrapper *) {}
+GenericExprWrapper *GenericExprWrapper::Copier(GenericExprWrapper *) {
+  return nullptr;
+}
 struct GenericAssignmentWrapper {
   static void Deleter(GenericAssignmentWrapper *);
+  static GenericAssignmentWrapper *Copier(GenericAssignmentWrapper *);
 };
 void GenericAssignmentWrapper::Deleter(GenericAssignmentWrapper *) {}
+GenericAssignmentWrapper *GenericAssignmentWrapper::Copier(
+    GenericAssignmentWrapper *) {
+  return nullptr;
+}
 struct ProcedureRef {
   static void Deleter(ProcedureRef *);
+  static ProcedureRef *Copier(ProcedureRef *);
 };
 void ProcedureRef::Deleter(ProcedureRef *) {}
+ProcedureRef *ProcedureRef::Copier(ProcedureRef *) { return nullptr; }
 } // namespace Fortran::evaluate