9#ifndef FORTRAN_PARSER_PARSE_TREE_H_ 
   10#define FORTRAN_PARSER_PARSE_TREE_H_ 
   20#include "char-block.h" 
   21#include "characters.h" 
   22#include "format-specification.h" 
   24#include "provenance.h" 
   25#include "flang/Common/idioms.h" 
   26#include "flang/Common/indirection.h" 
   27#include "flang/Common/reference.h" 
   28#include "flang/Support/Fortran.h" 
   29#include "llvm/ADT/ArrayRef.h" 
   30#include "llvm/Frontend/OpenACC/ACC.h.inc" 
   31#include "llvm/Frontend/OpenMP/OMP.h" 
   32#include "llvm/Frontend/OpenMP/OMPConstants.h" 
   53CLASS_TRAIT(EmptyTrait)
 
   54CLASS_TRAIT(WrapperTrait)
 
   55CLASS_TRAIT(UnionTrait)
 
   56CLASS_TRAIT(TupleTrait)
 
   57CLASS_TRAIT(ConstraintTrait)
 
   62namespace Fortran::semantics {
 
   79#define COPY_AND_ASSIGN_BOILERPLATE(classname) \ 
   80  classname(classname &&) = default; \ 
   81  classname &operator=(classname &&) = default; \ 
   82  classname(const classname &) = delete; \ 
   83  classname &operator=(const classname &) = delete 
   86#define BOILERPLATE(classname) \ 
   87  COPY_AND_ASSIGN_BOILERPLATE(classname); \ 
   92#define EMPTY_CLASS(classname) \ 
   95    classname(const classname &) {} \ 
   96    classname(classname &&) {} \ 
   97    classname &operator=(const classname &) { return *this; }; \ 
   98    classname &operator=(classname &&) { return *this; }; \ 
   99    using EmptyTrait = std::true_type; \ 
  104#define UNION_CLASS_BOILERPLATE(classname) \ 
  105  template <typename A, typename = common::NoLvalue<A>> \ 
  106  classname(A &&x) : u(std::move(x)) {} \ 
  107  using UnionTrait = std::true_type; \ 
  108  BOILERPLATE(classname) 
  112#define TUPLE_CLASS_BOILERPLATE(classname) \ 
  113  template <typename... Ts, typename = common::NoLvalue<Ts...>> \ 
  114  classname(Ts &&...args) : t(std::move(args)...) {} \ 
  115  using TupleTrait = std::true_type; \ 
  116  BOILERPLATE(classname) 
  120#define WRAPPER_CLASS_BOILERPLATE(classname, type) \ 
  121  BOILERPLATE(classname); \ 
  122  classname(type &&x) : v(std::move(x)) {} \ 
  123  using WrapperTrait = std::true_type; \ 
  126#define WRAPPER_CLASS(classname, type) \ 
  128    WRAPPER_CLASS_BOILERPLATE(classname, type); \ 
  160struct AllocatableStmt; 
 
  161struct AsynchronousStmt; 
 
  163struct CodimensionStmt; 
 
  164struct ContiguousStmt; 
 
  171struct OldParameterStmt;
 
  181struct EquivalenceStmt; 
 
  218struct SyncMemoryStmt; 
 
  260struct BasedPointerStmt;
 
  278using Location = 
const char *;
 
  283  constexpr Verbatim() {}
 
  284  COPY_AND_ASSIGN_BOILERPLATE(Verbatim);
 
  285  using EmptyTrait = std::true_type;
 
 
  294template <
typename A> 
struct Scalar {
 
  295  using ConstraintTrait = std::true_type;
 
  296  Scalar(Scalar &&that) = 
default;
 
  297  Scalar(A &&that) : thing(std::move(that)) {}
 
  298  Scalar &operator=(Scalar &&) = 
default;
 
 
  302template <
typename A> 
struct Constant {
 
  303  using ConstraintTrait = std::true_type;
 
  304  Constant(Constant &&that) = 
default;
 
  305  Constant(A &&that) : thing(std::move(that)) {}
 
  306  Constant &operator=(Constant &&) = 
default;
 
 
  310template <
typename A> 
struct Integer {
 
  311  using ConstraintTrait = std::true_type;
 
  312  Integer(Integer &&that) = 
default;
 
  313  Integer(A &&that) : thing(std::move(that)) {}
 
  314  Integer &operator=(Integer &&) = 
default;
 
 
  318template <
typename A> 
struct Logical {
 
  319  using ConstraintTrait = std::true_type;
 
  320  Logical(Logical &&that) = 
default;
 
  321  Logical(A &&that) : thing(std::move(that)) {}
 
  322  Logical &operator=(Logical &&) = 
default;
 
 
  326template <
typename A> 
struct DefaultChar {
 
  327  using ConstraintTrait = std::true_type;
 
  328  DefaultChar(DefaultChar &&that) = 
default;
 
  329  DefaultChar(A &&that) : thing(std::move(that)) {}
 
  330  DefaultChar &operator=(DefaultChar &&) = 
default;
 
 
  349using Label = common::Label; 
 
  353template <
typename A> 
struct UnlabeledStatement {
 
  354  explicit UnlabeledStatement(A &&s) : statement(std::move(s)) {}
 
 
  358template <
typename A> 
struct Statement : 
public UnlabeledStatement<A> {
 
  359  Statement(std::optional<long> &&lab, A &&s)
 
  360      : UnlabeledStatement<A>{std::move(s)}, label(std::move(lab)) {}
 
  361  std::optional<Label> label;
 
 
  365EMPTY_CLASS(ErrorRecovery);
 
  377  std::variant<common::Indirection<AccessStmt>,
 
 
  399  std::variant<common::Indirection<DerivedTypeDef>,
 
 
  418  std::variant<Statement<common::Indirection<ImplicitStmt>>,
 
 
  429WRAPPER_CLASS(ImplicitPart, std::list<ImplicitPartStmt>);
 
  436  std::variant<SpecificationConstruct, Statement<common::Indirection<DataStmt>>,
 
 
  450  std::tuple<std::list<OpenACCDeclarativeConstruct>,
 
  451      std::list<OpenMPDeclarativeConstruct>,
 
  452      std::list<common::Indirection<CompilerDirective>>,
 
  453      std::list<Statement<common::Indirection<UseStmt>>>,
 
  454      std::list<Statement<common::Indirection<ImportStmt>>>, ImplicitPart,
 
  455      std::list<DeclarationConstruct>>
 
 
  462  std::variant<common::Indirection<FunctionSubprogram>,
 
 
  469EMPTY_CLASS(ContainsStmt);
 
  474  std::tuple<Statement<ContainsStmt>, std::list<InternalSubprogram>> t;
 
 
  478EMPTY_CLASS(ContinueStmt);
 
  481EMPTY_CLASS(FailImageStmt);
 
  495  std::variant<common::Indirection<AllocateStmt>,
 
 
  552  std::variant<ExecutableConstruct, Statement<common::Indirection<FormatStmt>>,
 
 
  561using Block = std::list<ExecutionPartConstruct>;
 
  562WRAPPER_CLASS(ExecutionPart, Block);
 
  569  std::variant<common::Indirection<MainProgram>,
 
 
  580WRAPPER_CLASS(Program, std::list<ProgramUnit>);
 
  584  std::string ToString()
 const { 
return source.ToString(); }
 
 
  590WRAPPER_CLASS(Keyword, 
Name);
 
  593WRAPPER_CLASS(NamedConstant, 
Name);
 
  600WRAPPER_CLASS(DefinedOpName, 
Name);
 
  610  ENUM_CLASS(IntrinsicOperator, Power, Multiply, Divide, Add, Subtract, Concat,
 
  611      LT, LE, EQ, NE, GE, GT, NOT, AND, OR, EQV, NEQV)
 
  612  std::variant<DefinedOpName, IntrinsicOperator> u;
 
 
  616using ObjectName = 
Name;
 
  622  BOILERPLATE(ImportStmt);
 
  623  ImportStmt(common::ImportKind &&k) : kind{k} {}
 
  624  ImportStmt(std::list<Name> &&n) : names(std::move(n)) {}
 
  625  ImportStmt(common::ImportKind &&, std::list<Name> &&);
 
  626  common::ImportKind kind{common::ImportKind::Default};
 
  627  std::list<Name> names;
 
 
  636    TUPLE_CLASS_BOILERPLATE(
Group);
 
  637    std::tuple<Name, std::list<Name>> t;
 
 
  639  WRAPPER_CLASS_BOILERPLATE(
NamelistStmt, std::list<Group>);
 
 
  647  EMPTY_CLASS(Deferred); 
 
  648  std::variant<ScalarIntExpr, Star, Deferred> u;
 
 
  656  WRAPPER_CLASS(StarSize, std::uint64_t);
 
  657  std::variant<ScalarIntConstantExpr, StarSize> u;
 
 
  661WRAPPER_CLASS(IntegerTypeSpec, std::optional<KindSelector>);
 
  663WRAPPER_CLASS(UnsignedTypeSpec, std::optional<KindSelector>);
 
  668  std::variant<TypeParamValue, std::uint64_t> u;
 
 
  674  std::variant<TypeParamValue, CharLength> u;
 
 
  683  UNION_CLASS_BOILERPLATE(CharSelector);
 
  684  struct LengthAndKind {
 
  685    BOILERPLATE(LengthAndKind);
 
  686    LengthAndKind(std::optional<TypeParamValue> &&l, ScalarIntConstantExpr &&k)
 
  687        : length(std::move(l)), kind(std::move(k)) {}
 
  688    std::optional<TypeParamValue> length;
 
  689    ScalarIntConstantExpr kind;
 
 
  692      : u{
LengthAndKind{std::make_optional(std::move(l)), std::move(k)}} {}
 
  693  CharSelector(ScalarIntConstantExpr &&k, std::optional<TypeParamValue> &&l)
 
  694      : u{LengthAndKind{std::move(l), std::move(k)}} {}
 
  695  std::variant<LengthSelector, LengthAndKind> u;
 
 
  707    Real(std::optional<KindSelector> &&k) : kind{std::move(k)} {}
 
  708    std::optional<KindSelector> kind;
 
 
  710  EMPTY_CLASS(DoublePrecision);
 
  712    BOILERPLATE(Complex);
 
  713    Complex(std::optional<KindSelector> &&k) : kind{std::move(k)} {}
 
  714    std::optional<KindSelector> kind;
 
 
  717    BOILERPLATE(Character);
 
  718    Character(std::optional<CharSelector> &&s) : selector{std::move(s)} {}
 
  719    std::optional<CharSelector> selector;
 
 
  722    BOILERPLATE(Logical);
 
  723    Logical(std::optional<KindSelector> &&k) : kind{std::move(k)} {}
 
  724    std::optional<KindSelector> kind;
 
 
  726  EMPTY_CLASS(DoubleComplex);
 
  727  std::variant<IntegerTypeSpec, UnsignedTypeSpec, 
Real, DoublePrecision,
 
 
  735  std::variant<IntegerTypeSpec, IntrinsicTypeSpec::Real, UnsignedTypeSpec> u;
 
 
  740  EMPTY_CLASS(PairVectorTypeSpec);
 
  741  EMPTY_CLASS(QuadVectorTypeSpec);
 
  742  std::variant<IntrinsicVectorTypeSpec, PairVectorTypeSpec, QuadVectorTypeSpec>
 
 
  756  std::tuple<Name, std::list<TypeParamSpec>> t;
 
 
  763  std::variant<IntrinsicTypeSpec, DerivedTypeSpec> u;
 
 
  783  EMPTY_CLASS(ClassStar);
 
  784  EMPTY_CLASS(TypeStar);
 
  785  WRAPPER_CLASS(Record, 
Name);
 
 
  794  std::variant<std::uint64_t, Scalar<Integer<Constant<Name>>>> u;
 
 
  801  std::tuple<CharBlock, std::optional<KindParam>> t;
 
 
  807  std::tuple<CharBlock, std::optional<KindParam>> t;
 
 
  813  std::tuple<CharBlock, std::optional<KindParam>> t;
 
 
  817enum class Sign { Positive, Negative };
 
  824struct RealLiteralConstant {
 
  825  BOILERPLATE(RealLiteralConstant);
 
  827    COPY_AND_ASSIGN_BOILERPLATE(Real);
 
 
  831  RealLiteralConstant(
Real &&r, std::optional<KindParam> &&k)
 
  832      : real{std::move(r)}, kind{std::move(k)} {}
 
  834  std::optional<KindParam> kind;
 
 
  859  std::tuple<ComplexPart, ComplexPart> t; 
 
 
  865  std::tuple<Sign, ComplexLiteralConstant> t;
 
 
  873  std::tuple<std::optional<KindParam>, std::string> t;
 
  874  std::string GetString()
 const { 
return std::get<std::string>(t); }
 
 
  880  std::string GetString()
 const { 
return v; }
 
 
  887  std::tuple<bool, std::optional<KindParam>> t;
 
 
  897WRAPPER_CLASS(BOZLiteralConstant, std::string);
 
  913  ENUM_CLASS(Kind, Public, Private)
 
 
  919EMPTY_CLASS(Abstract);
 
  923  WRAPPER_CLASS(Extends, 
Name);
 
  924  std::variant<Abstract, AccessSpec, BindC, Extends> u;
 
 
  931  std::tuple<std::list<TypeAttrSpec>, 
Name, std::list<Name>> t;
 
 
  935EMPTY_CLASS(SequenceStmt);
 
  939EMPTY_CLASS(PrivateStmt);
 
  944  std::variant<PrivateStmt, SequenceStmt> u;
 
 
  950  std::tuple<Name, std::optional<ScalarIntConstantExpr>> t;
 
 
  958  std::tuple<IntegerTypeSpec, common::TypeParamAttr, std::list<TypeParamDecl>>
 
 
  963WRAPPER_CLASS(SpecificationExpr, ScalarIntExpr);
 
  970  std::tuple<std::optional<SpecificationExpr>, SpecificationExpr> t;
 
 
  975WRAPPER_CLASS(DeferredCoshapeSpecList, 
int);
 
  983  std::tuple<std::list<ExplicitShapeSpec>, std::optional<SpecificationExpr>> t;
 
 
  989  std::variant<DeferredCoshapeSpecList, ExplicitCoshapeSpec> u;
 
 
  994WRAPPER_CLASS(DeferredShapeSpecList, 
int);
 
 1000  std::variant<std::list<ExplicitShapeSpec>, DeferredShapeSpecList> u;
 
 
 1008EMPTY_CLASS(Allocatable);
 
 1009EMPTY_CLASS(Pointer);
 
 1010EMPTY_CLASS(Contiguous);
 
 1031  std::variant<ConstantExpr, NullInit, InitialDataTarget,
 
 1032      std::list<common::Indirection<DataStmtValue>>>
 
 
 1042struct ComponentDecl {
 
 1043  TUPLE_CLASS_BOILERPLATE(ComponentDecl);
 
 1045      std::optional<ComponentArraySpec> &&aSpec,
 
 1046      std::optional<CoarraySpec> &&coaSpec,
 
 1047      std::optional<Initialization> &&init)
 
 1048      : t{std::move(name), std::move(aSpec), std::move(coaSpec),
 
 1049            std::move(length), std::move(init)} {}
 
 1050  std::tuple<Name, std::optional<ComponentArraySpec>,
 
 1051      std::optional<CoarraySpec>, std::optional<CharLength>,
 
 1052      std::optional<Initialization>>
 
 
 1060  std::tuple<Name, std::optional<ComponentArraySpec>, std::optional<CharLength>>
 
 
 1066  std::variant<ComponentDecl, FillDecl> u;
 
 
 1074  std::tuple<DeclarationTypeSpec, std::list<ComponentAttrSpec>,
 
 1075      std::list<ComponentOrFill>>
 
 
 1082WRAPPER_CLASS(Pass, std::optional<Name>);
 
 1085  std::variant<AccessSpec, NoPass, Pass, Pointer> u;
 
 
 1092  std::variant<NullInit, Name> u;
 
 
 1099  std::variant<Name, DeclarationTypeSpec> u;
 
 
 1105  std::tuple<Name, std::optional<ProcPointerInit>> t;
 
 
 1113  std::tuple<std::optional<ProcInterface>, std::list<ProcComponentAttrSpec>,
 
 1114      std::list<ProcDecl>>
 
 
 1132  EMPTY_CLASS(Deferred);
 
 1133  EMPTY_CLASS(Non_Overridable);
 
 1134  std::variant<AccessSpec, Deferred, Non_Overridable, NoPass, Pass> u;
 
 
 1140  std::tuple<Name, std::optional<Name>> t;
 
 
 1150  struct WithoutInterface {
 
 1151    BOILERPLATE(WithoutInterface);
 
 1153        std::list<BindAttr> &&as, std::list<TypeBoundProcDecl> &&ds)
 
 1154        : attributes(std::move(as)), declarations(std::move(ds)) {}
 
 1155    std::list<BindAttr> attributes;
 
 1156    std::list<TypeBoundProcDecl> declarations;
 
 
 1158  struct WithInterface {
 
 1159    BOILERPLATE(WithInterface);
 
 1160    WithInterface(
Name &&n, std::list<BindAttr> &&as, std::list<Name> &&bs)
 
 1161        : interfaceName(std::move(n)), attributes(std::move(as)),
 
 1162          bindingNames(std::move(bs)) {}
 
 1164    std::list<BindAttr> attributes;
 
 1165    std::list<Name> bindingNames;
 
 
 1167  std::variant<WithoutInterface, WithInterface> u;
 
 
 1180WRAPPER_CLASS(FinalProcedureStmt, std::list<Name>);
 
 1196  std::tuple<Statement<ContainsStmt>, std::optional<Statement<PrivateStmt>>,
 
 1197      std::list<Statement<TypeBoundProcBinding>>>
 
 
 1202WRAPPER_CLASS(EndTypeStmt, std::optional<Name>);
 
 1210  std::tuple<Statement<DerivedTypeStmt>, std::list<Statement<TypeParamDefStmt>>,
 
 1211      std::list<Statement<PrivateOrSequence>>,
 
 1212      std::list<Statement<ComponentDefStmt>>,
 
 
 1225  std::tuple<std::optional<Keyword>, ComponentDataSource> t;
 
 
 1231  std::tuple<DerivedTypeSpec, std::list<ComponentSpec>> t;
 
 
 1235EMPTY_CLASS(EnumDefStmt);
 
 1240  std::tuple<NamedConstant, std::optional<ScalarIntConstantExpr>> t;
 
 
 1244WRAPPER_CLASS(EnumeratorDefStmt, std::list<Enumerator>);
 
 1247EMPTY_CLASS(EndEnumStmt);
 
 1253  TUPLE_CLASS_BOILERPLATE(
EnumDef);
 
 1254  std::tuple<Statement<EnumDefStmt>, std::list<Statement<EnumeratorDefStmt>>,
 
 
 1262    TUPLE_CLASS_BOILERPLATE(
Triplet);
 
 1263    std::tuple<ScalarIntExpr, ScalarIntExpr, std::optional<ScalarIntExpr>> t;
 
 
 1265  UNION_CLASS_BOILERPLATE(
AcValue);
 
 1266  std::variant<Triplet, common::Indirection<Expr>,
 
 
 1273  BOILERPLATE(AcSpec);
 
 1274  AcSpec(std::optional<TypeSpec> &&ts, std::list<AcValue> &&xs)
 
 1275      : type(std::move(ts)), values(std::move(xs)) {}
 
 1276  explicit AcSpec(
TypeSpec &&ts) : type{std::move(ts)} {}
 
 1277  std::optional<TypeSpec> type;
 
 1278  std::list<AcValue> values;
 
 
 1282WRAPPER_CLASS(ArrayConstructor, 
AcSpec);
 
 1287template <
typename VAR, 
typename BOUND> 
struct LoopBounds {
 
 1288  LoopBounds(LoopBounds &&that) = 
default;
 
 1290      VAR &&name, BOUND &&lower, BOUND &&upper, std::optional<BOUND> &&step)
 
 1291      : name{std::move(name)}, lower{std::move(lower)}, upper{std::move(upper)},
 
 1292        step{std::move(step)} {}
 
 1293  LoopBounds &operator=(LoopBounds &&) = 
default;
 
 1296  std::optional<BOUND> step;
 
 
 1309  std::tuple<std::optional<IntegerTypeSpec>, Bounds> t;
 
 
 1324  std::tuple<std::optional<ScalarDefaultCharConstantExpr>, 
bool> t;
 
 
 1330  std::tuple<NamedConstant, ConstantExpr> t;
 
 
 1334WRAPPER_CLASS(ParameterStmt, std::list<NamedConstantDef>);
 
 1337WRAPPER_CLASS(AssumedShapeSpec, std::optional<SpecificationExpr>);
 
 1340WRAPPER_CLASS(AssumedImpliedSpec, std::optional<SpecificationExpr>);
 
 1345  std::tuple<std::list<ExplicitShapeSpec>, AssumedImpliedSpec> t;
 
 
 1352WRAPPER_CLASS(ImpliedShapeSpec, std::list<AssumedImpliedSpec>);
 
 1355EMPTY_CLASS(AssumedRankSpec);
 
 1363  std::variant<std::list<ExplicitShapeSpec>, std::list<AssumedShapeSpec>,
 
 1364      DeferredShapeSpecList, 
AssumedSizeSpec, ImpliedShapeSpec, AssumedRankSpec>
 
 
 1370  ENUM_CLASS(Intent, In, Out, InOut)
 
 1371  WRAPPER_CLASS_BOILERPLATE(
IntentSpec, Intent);
 
 
 1381EMPTY_CLASS(Asynchronous);
 
 1382EMPTY_CLASS(External);
 
 1383EMPTY_CLASS(Intrinsic);
 
 1384EMPTY_CLASS(Optional);
 
 1385EMPTY_CLASS(Parameter);
 
 1386EMPTY_CLASS(Protected);
 
 1390EMPTY_CLASS(Volatile);
 
 1395      Parameter, Pointer, Protected, Save, Target, Value, Volatile,
 
 1396      common::CUDADataAttr>
 
 
 1407  TUPLE_CLASS_BOILERPLATE(EntityDecl);
 
 1408  EntityDecl(ObjectName &&name, 
CharLength &&length,
 
 1409      std::optional<ArraySpec> &&aSpec, std::optional<CoarraySpec> &&coaSpec,
 
 1410      std::optional<Initialization> &&init)
 
 1411      : t{std::move(name), std::move(aSpec), std::move(coaSpec),
 
 1412            std::move(length), std::move(init)} {}
 
 1413  std::tuple<ObjectName, std::optional<ArraySpec>, std::optional<CoarraySpec>,
 
 1414      std::optional<CharLength>, std::optional<Initialization>>
 
 
 1422  std::tuple<DeclarationTypeSpec, std::list<AttrSpec>, std::list<EntityDecl>> t;
 
 
 1432  std::tuple<AccessSpec, std::list<AccessId>> t;
 
 
 1441  std::tuple<ObjectName, std::optional<ArraySpec>, std::optional<CoarraySpec>>
 
 
 1446WRAPPER_CLASS(AllocatableStmt, std::list<ObjectDecl>);
 
 1449WRAPPER_CLASS(AsynchronousStmt, std::list<ObjectName>);
 
 1454  ENUM_CLASS(Kind, Object, Common)
 
 1455  std::tuple<Kind, Name> t;
 
 
 1461  std::tuple<LanguageBindingSpec, std::list<BindEntity>> t;
 
 
 1467  std::tuple<Name, CoarraySpec> t;
 
 
 1471WRAPPER_CLASS(CodimensionStmt, std::list<CodimensionDecl>);
 
 1474WRAPPER_CLASS(ContiguousStmt, std::list<ObjectName>);
 
 1493  mutable TypedExpr typedExpr;
 
 1494  std::variant<common::Indirection<CharLiteralConstantSubstring>,
 
 
 1507  std::variant<IntLiteralConstant, Scalar<Integer<ConstantSubobject>>> u;
 
 
 1513  mutable std::int64_t repetitions{1}; 
 
 
 1521  std::variant<Scalar<common::Indirection<Designator>>,
 
 
 1534  std::tuple<std::list<DataIDoObject>, std::optional<IntegerTypeSpec>, Bounds>
 
 
 1541  std::variant<common::Indirection<Variable>, 
DataImpliedDo> u;
 
 
 1547  std::tuple<std::list<DataStmtObject>, std::list<DataStmtValue>> t;
 
 
 1551WRAPPER_CLASS(DataStmt, std::list<DataStmtSet>);
 
 1559    std::tuple<Name, ArraySpec> t;
 
 
 1561  WRAPPER_CLASS_BOILERPLATE(
DimensionStmt, std::list<Declaration>);
 
 
 1567  std::tuple<IntentSpec, std::list<Name>> t;
 
 
 1571WRAPPER_CLASS(OptionalStmt, std::list<Name>);
 
 1577  std::tuple<Name, std::optional<DeferredShapeSpecList>> t;
 
 
 1581WRAPPER_CLASS(PointerStmt, std::list<PointerDecl>);
 
 1584WRAPPER_CLASS(ProtectedStmt, std::list<Name>);
 
 1590  ENUM_CLASS(Kind, Entity, Common)
 
 1591  std::tuple<Kind, Name> t;
 
 
 1595WRAPPER_CLASS(SaveStmt, std::list<SavedEntity>);
 
 1598WRAPPER_CLASS(TargetStmt, std::list<ObjectDecl>);
 
 1601WRAPPER_CLASS(ValueStmt, std::list<Name>);
 
 1604WRAPPER_CLASS(VolatileStmt, std::list<ObjectName>);
 
 1609  std::tuple<Location, std::optional<Location>> t;
 
 
 1615  std::tuple<DeclarationTypeSpec, std::list<LetterSpec>> t;
 
 
 1624  ENUM_CLASS(ImplicitNoneNameSpec, External, Type) 
 
 1625  std::variant<std::list<ImplicitSpec>, std::list<ImplicitNoneNameSpec>> u;
 
 
 1631  std::tuple<Name, std::optional<ArraySpec>> t;
 
 
 1639    TUPLE_CLASS_BOILERPLATE(
Block);
 
 1640    std::tuple<std::optional<Name>, std::list<CommonBlockObject>> t;
 
 
 1642  BOILERPLATE(CommonStmt);
 
 1643  CommonStmt(std::optional<Name> &&, std::list<CommonBlockObject> &&,
 
 1644      std::list<Block> &&);
 
 1646  std::list<Block> blocks;
 
 
 1654WRAPPER_CLASS(EquivalenceStmt, std::list<std::list<EquivalenceObject>>);
 
 1659  std::tuple<std::optional<ScalarIntExpr>, std::optional<ScalarIntExpr>> t;
 
 
 1663using Subscript = ScalarIntExpr;
 
 1668  std::tuple<std::optional<Subscript>, std::optional<Subscript>,
 
 1669      std::optional<Subscript>>
 
 
 1677  std::variant<IntExpr, SubscriptTriplet> u;
 
 
 1681using Cosubscript = ScalarIntExpr;
 
 1691  WRAPPER_CLASS(Team_Number, ScalarIntExpr);
 
 1693  std::variant<Stat, TeamValue, Team_Number> u;
 
 
 1700  std::tuple<std::list<Cosubscript>, std::list<ImageSelectorSpec>> t;
 
 
 1705  UNION_CLASS_BOILERPLATE(Expr);
 
 1709    using IntrinsicUnary::IntrinsicUnary;
 
 
 1712    using IntrinsicUnary::IntrinsicUnary;
 
 
 1715    using IntrinsicUnary::IntrinsicUnary;
 
 
 1717  struct NOT : 
public IntrinsicUnary {
 
 1718    using IntrinsicUnary::IntrinsicUnary;
 
 
 1725    std::tuple<DefinedOpName, common::Indirection<Expr>> t;
 
 
 1733    using IntrinsicBinary::IntrinsicBinary;
 
 
 1736    using IntrinsicBinary::IntrinsicBinary;
 
 
 1739    using IntrinsicBinary::IntrinsicBinary;
 
 
 1742    using IntrinsicBinary::IntrinsicBinary;
 
 
 1745    using IntrinsicBinary::IntrinsicBinary;
 
 
 1748    using IntrinsicBinary::IntrinsicBinary;
 
 
 1751    using IntrinsicBinary::IntrinsicBinary;
 
 
 1754    using IntrinsicBinary::IntrinsicBinary;
 
 
 1757    using IntrinsicBinary::IntrinsicBinary;
 
 
 1760    using IntrinsicBinary::IntrinsicBinary;
 
 
 1763    using IntrinsicBinary::IntrinsicBinary;
 
 
 1766    using IntrinsicBinary::IntrinsicBinary;
 
 
 1769    using IntrinsicBinary::IntrinsicBinary;
 
 
 1772    using IntrinsicBinary::IntrinsicBinary;
 
 
 1775    using IntrinsicBinary::IntrinsicBinary;
 
 
 1778    using IntrinsicBinary::IntrinsicBinary;
 
 
 1783    using IntrinsicBinary::IntrinsicBinary;
 
 
 1788    std::tuple<DefinedOpName, common::Indirection<Expr>,
 
 
 1796  mutable TypedExpr typedExpr;
 
 1800  std::variant<common::Indirection<CharLiteralConstantSubstring>,
 
 1804      Add, 
Subtract, 
Concat, 
LT, 
LE, 
EQ, 
NE, 
GE, 
GT, 
AND, 
OR, 
EQV, 
NEQV,
 
 
 1811  BOILERPLATE(PartRef);
 
 1812  PartRef(
Name &&n, std::list<SectionSubscript> &&ss,
 
 1813      std::optional<ImageSelector> &&is)
 
 1814      : name{std::move(n)}, subscripts(std::move(ss)),
 
 1815        imageSelector{std::move(is)} {}
 
 1817  std::list<SectionSubscript> subscripts;
 
 1818  std::optional<ImageSelector> imageSelector;
 
 
 1823  UNION_CLASS_BOILERPLATE(DataRef);
 
 1824  explicit DataRef(std::list<PartRef> &&);
 
 1825  std::variant<Name, common::Indirection<StructureComponent>,
 
 
 1841  std::tuple<DataRef, SubstringRange> t;
 
 
 1846  std::tuple<CharLiteralConstant, SubstringRange> t;
 
 
 1863  bool EndsInBareName() 
const;
 
 1865  std::variant<DataRef, Substring> u;
 
 
 1871  mutable TypedExpr typedExpr;
 
 1873  std::variant<common::Indirection<Designator>,
 
 
 1891struct StructureComponent {
 
 1892  BOILERPLATE(StructureComponent);
 
 1894      : base{std::move(dr)}, component(std::move(n)) {}
 
 
 1906struct CoindexedNamedObject {
 
 1907  BOILERPLATE(CoindexedNamedObject);
 
 1909      : base{std::move(dr)}, imageSelector{std::move(is)} {}
 
 
 1915struct ArrayElement {
 
 1916  BOILERPLATE(ArrayElement);
 
 1917  ArrayElement(
DataRef &&dr, std::list<SectionSubscript> &&ss)
 
 1918      : base{std::move(dr)}, subscripts(std::move(ss)) {}
 
 1923  std::list<SectionSubscript> subscripts;
 
 
 1929  mutable TypedExpr typedExpr;
 
 1930  std::variant<Name, StructureComponent> u;
 
 
 1935using BoundExpr = ScalarIntExpr;
 
 1941  std::tuple<std::optional<BoundExpr>, BoundExpr> t;
 
 
 1950  std::tuple<std::list<AllocateCoshapeSpec>, std::optional<BoundExpr>> t;
 
 
 1958  std::tuple<AllocateObject, std::list<AllocateShapeSpec>,
 
 1959      std::optional<AllocateCoarraySpec>>
 
 
 1964WRAPPER_CLASS(StatVariable, ScalarIntVariable);
 
 1968WRAPPER_CLASS(MsgVariable, ScalarDefaultCharVariable);
 
 1974  std::variant<StatVariable, MsgVariable> u;
 
 
 1989  std::variant<Mold, Source, StatOrErrmsg, Stream, Pinned> u;
 
 
 1996  std::tuple<std::optional<TypeSpec>, std::list<Allocation>,
 
 1997      std::list<AllocOpt>>
 
 
 2005  mutable TypedExpr typedExpr;
 
 2006  std::variant<Name, StructureComponent> u;
 
 
 2010WRAPPER_CLASS(NullifyStmt, std::list<PointerObject>);
 
 2016  std::tuple<std::list<AllocateObject>, std::list<StatOrErrmsg>> t;
 
 
 2022  using TypedAssignment =
 
 2024  mutable TypedAssignment typedAssignment;
 
 2025  std::tuple<Variable, Expr> t;
 
 
 2029WRAPPER_CLASS(BoundsSpec, BoundExpr);
 
 2034  std::tuple<BoundExpr, BoundExpr> t;
 
 
 2046    UNION_CLASS_BOILERPLATE(
Bounds);
 
 2047    std::variant<std::list<BoundsRemapping>, std::list<BoundsSpec>> u;
 
 
 2050  mutable AssignmentStmt::TypedAssignment typedAssignment;
 
 2051  std::tuple<DataRef, Bounds, Expr> t;
 
 
 2059  std::tuple<LogicalExpr, AssignmentStmt> t;
 
 
 2065  std::tuple<std::optional<Name>, LogicalExpr> t;
 
 
 2081  std::tuple<LogicalExpr, std::optional<Name>> t;
 
 
 2085WRAPPER_CLASS(ElsewhereStmt, std::optional<Name>);
 
 2088WRAPPER_CLASS(EndWhereStmt, std::optional<Name>);
 
 2097    std::tuple<Statement<MaskedElsewhereStmt>, std::list<WhereBodyConstruct>> t;
 
 
 2101    std::tuple<Statement<ElsewhereStmt>, std::list<WhereBodyConstruct>> t;
 
 
 2104  std::tuple<Statement<WhereConstructStmt>, std::list<WhereBodyConstruct>,
 
 2105      std::list<MaskedElsewhere>, std::optional<Elsewhere>,
 
 
 2120  std::variant<AssignmentStmt, PointerAssignmentStmt> u;
 
 
 2126  std::tuple<common::Indirection<ConcurrentHeader>,
 
 
 2143WRAPPER_CLASS(EndForallStmt, std::optional<Name>);
 
 2149  std::tuple<Statement<ForallConstructStmt>, std::list<ForallBodyConstruct>,
 
 
 2157  std::variant<Expr, Variable> u;
 
 
 2163  std::tuple<Name, Selector> t;
 
 
 2170  std::tuple<std::optional<Name>, std::list<Association>> t;
 
 
 2174WRAPPER_CLASS(EndAssociateStmt, std::optional<Name>);
 
 2183WRAPPER_CLASS(BlockStmt, std::optional<Name>);
 
 2186WRAPPER_CLASS(EndBlockStmt, std::optional<Name>);
 
 2201  std::tuple<Statement<BlockStmt>, BlockSpecificationPart, Block,
 
 
 2209  std::tuple<CodimensionDecl, Selector> t;
 
 
 2217  std::tuple<std::optional<Name>, TeamValue, std::list<CoarrayAssociation>,
 
 2218      std::list<StatOrErrmsg>>
 
 
 2226  std::tuple<std::list<StatOrErrmsg>, std::optional<Name>> t;
 
 
 2239  std::tuple<std::optional<Name>, std::list<StatOrErrmsg>> t;
 
 
 2243WRAPPER_CLASS(EndCriticalStmt, std::optional<Name>);
 
 2257  std::tuple<Name, ScalarIntExpr, ScalarIntExpr, std::optional<ScalarIntExpr>>
 
 
 2266  std::tuple<std::optional<IntegerTypeSpec>, std::list<ConcurrentControl>,
 
 2267      std::optional<ScalarLogicalExpr>>
 
 
 2278      Operator, Plus, Multiply, Max, Min, Iand, Ior, Ieor, And, Or, Eqv, Neqv)
 
 
 2289  WRAPPER_CLASS(Local, std::list<Name>);
 
 2290  WRAPPER_CLASS(LocalInit, std::list<Name>);
 
 2292    TUPLE_CLASS_BOILERPLATE(
Reduce);
 
 2294    std::tuple<Operator, std::list<Name>> t;
 
 
 2296  WRAPPER_CLASS(Shared, std::list<Name>);
 
 2297  EMPTY_CLASS(DefaultNone);
 
 2298  std::variant<Local, LocalInit, Reduce, Shared, DefaultNone> u;
 
 
 2311    std::tuple<ConcurrentHeader, std::list<LocalitySpec>> t;
 
 
 2314  std::variant<Bounds, ScalarLogicalExpr, Concurrent> u;
 
 
 2321  std::tuple<Label, std::optional<LoopControl>> t;
 
 
 2327  std::tuple<std::optional<Name>, std::optional<Label>,
 
 2328      std::optional<LoopControl>>
 
 
 2333WRAPPER_CLASS(EndDoStmt, std::optional<Name>);
 
 2344  const std::optional<LoopControl> &GetLoopControl() 
const;
 
 2345  bool IsDoNormal() 
const;
 
 2346  bool IsDoWhile() 
const;
 
 2347  bool IsDoConcurrent() 
const;
 
 
 2352WRAPPER_CLASS(CycleStmt, std::optional<Name>);
 
 2357  std::tuple<std::optional<Name>, ScalarLogicalExpr> t;
 
 
 2364  std::tuple<ScalarLogicalExpr, std::optional<Name>> t;
 
 
 2368WRAPPER_CLASS(ElseStmt, std::optional<Name>);
 
 2371WRAPPER_CLASS(EndIfStmt, std::optional<Name>);
 
 2379    std::tuple<Statement<ElseIfStmt>, Block> t;
 
 
 2383    std::tuple<Statement<ElseStmt>, Block> t;
 
 
 2386  std::tuple<Statement<IfThenStmt>, Block, std::list<ElseIfBlock>,
 
 
 2393  TUPLE_CLASS_BOILERPLATE(
IfStmt);
 
 2394  std::tuple<ScalarLogicalExpr, UnlabeledStatement<ActionStmt>> t;
 
 
 2413    Range(std::optional<CaseValue> &&l, std::optional<CaseValue> &&u)
 
 2414        : lower{std::move(l)}, upper{std::move(u)} {}
 
 2415    std::optional<CaseValue> lower, upper; 
 
 
 2417  std::variant<CaseValue, Range> u;
 
 
 2421EMPTY_CLASS(Default);
 
 2425  std::variant<std::list<CaseValueRange>, Default> u;
 
 
 2431  std::tuple<CaseSelector, std::optional<Name>> t;
 
 
 2437WRAPPER_CLASS(EndSelectStmt, std::optional<Name>);
 
 2443    TUPLE_CLASS_BOILERPLATE(
Case);
 
 2444    std::tuple<Statement<CaseStmt>, Block> t;
 
 
 2447  std::tuple<Statement<SelectCaseStmt>, std::list<Case>,
 
 
 2457  std::tuple<std::optional<Name>, std::optional<Name>, 
Selector> t;
 
 
 2466    UNION_CLASS_BOILERPLATE(
Rank);
 
 2467    std::variant<ScalarIntConstantExpr, Star, Default> u;
 
 
 2470  std::tuple<Rank, std::optional<Name>> t;
 
 
 2480    std::tuple<Statement<SelectRankCaseStmt>, Block> t;
 
 
 2482  std::tuple<Statement<SelectRankStmt>, std::list<RankCase>,
 
 
 2492  std::tuple<std::optional<Name>, std::optional<Name>, 
Selector> t;
 
 
 2501    UNION_CLASS_BOILERPLATE(
Guard);
 
 2502    std::variant<TypeSpec, DerivedTypeSpec, Default> u;
 
 
 2505  std::tuple<Guard, std::optional<Name>> t;
 
 
 2514    std::tuple<Statement<TypeGuardStmt>, Block> t;
 
 
 2516  std::tuple<Statement<SelectTypeStmt>, std::list<TypeCase>,
 
 
 2522WRAPPER_CLASS(ExitStmt, std::optional<Name>);
 
 2525WRAPPER_CLASS(GotoStmt, Label);
 
 2530  std::tuple<std::list<Label>, ScalarIntExpr> t;
 
 
 2543  ENUM_CLASS(Kind, Stop, ErrorStop)
 
 2545  std::tuple<Kind, std::optional<StopCode>, std::optional<ScalarLogicalExpr>> t;
 
 
 2552  std::tuple<Scalar<Variable>, std::list<EventWaitSpec>> t;
 
 
 2556WRAPPER_CLASS(SyncAllStmt, std::list<StatOrErrmsg>);
 
 2563    std::variant<IntExpr, Star> u;
 
 
 2566  std::tuple<ImageSet, std::list<StatOrErrmsg>> t;
 
 
 2570WRAPPER_CLASS(SyncMemoryStmt, std::list<StatOrErrmsg>);
 
 2575  std::tuple<TeamValue, std::list<StatOrErrmsg>> t;
 
 
 2584  std::tuple<EventVariable, std::list<StatOrErrmsg>> t;
 
 
 2590  std::variant<ScalarIntExpr, StatOrErrmsg> u;
 
 
 2598  std::tuple<EventVariable, std::list<EventWaitSpec>> t;
 
 
 2611    std::variant<ScalarIntExpr, StatOrErrmsg> u;
 
 
 2614  std::tuple<ScalarIntExpr, TeamVariable, std::list<FormTeamSpec>> t;
 
 
 2625    std::variant<Scalar<Logical<Variable>>, 
StatOrErrmsg> u;
 
 
 2628  std::tuple<LockVariable, std::list<LockStat>> t;
 
 
 2634  std::tuple<LockVariable, std::list<StatOrErrmsg>> t;
 
 
 2638WRAPPER_CLASS(FileUnitNumber, ScalarIntExpr);
 
 2648  UNION_CLASS_BOILERPLATE(
IoUnit);
 
 2649  std::variant<Variable, common::Indirection<Expr>, Star> u;
 
 
 2653using FileNameExpr = ScalarDefaultCharExpr;
 
 2672WRAPPER_CLASS(StatusExpr, ScalarDefaultCharExpr);
 
 2673WRAPPER_CLASS(ErrLabel, Label);
 
 2678    ENUM_CLASS(Kind, Access, Action, Asynchronous, Blank, Decimal, Delim,
 
 2679        Encoding, Form, Pad, Position, Round, Sign,
 
 2680         Carriagecontrol, Convert, Dispose)
 
 2682    std::tuple<Kind, ScalarDefaultCharExpr> t;
 
 
 2684  WRAPPER_CLASS(Recl, ScalarIntExpr);
 
 2685  WRAPPER_CLASS(Newunit, ScalarIntVariable);
 
 2686  std::variant<FileUnitNumber, FileNameExpr, 
CharExpr, MsgVariable,
 
 2687      StatVariable, Recl, Newunit, ErrLabel, StatusExpr>
 
 
 2692WRAPPER_CLASS(OpenStmt, std::list<ConnectSpec>);
 
 2702    std::variant<FileUnitNumber, StatVariable, MsgVariable, ErrLabel,
 
 
 2706  WRAPPER_CLASS_BOILERPLATE(
CloseStmt, std::list<CloseSpec>);
 
 
 2712  UNION_CLASS_BOILERPLATE(
Format);
 
 2713  std::variant<Expr, Label, Star> u;
 
 
 2717WRAPPER_CLASS(IdVariable, ScalarIntVariable);
 
 2731WRAPPER_CLASS(EndLabel, Label);
 
 2732WRAPPER_CLASS(EorLabel, Label);
 
 2736    ENUM_CLASS(Kind, Advance, Blank, Decimal, Delim, Pad, Round, Sign)
 
 2738    std::tuple<Kind, ScalarDefaultCharExpr> t;
 
 
 2740  WRAPPER_CLASS(Asynchronous, ScalarDefaultCharConstantExpr);
 
 2741  WRAPPER_CLASS(Pos, ScalarIntExpr);
 
 2742  WRAPPER_CLASS(Rec, ScalarIntExpr);
 
 2743  WRAPPER_CLASS(Size, ScalarIntVariable);
 
 2745      ErrLabel, IdVariable, MsgVariable, StatVariable, Pos, Rec, Size>
 
 
 2752  std::variant<Variable, common::Indirection<InputImpliedDo>> u;
 
 
 2759  BOILERPLATE(ReadStmt);
 
 2760  ReadStmt(std::optional<IoUnit> &&i, std::optional<Format> &&f,
 
 2761      std::list<IoControlSpec> &&cs, std::list<InputItem> &&its)
 
 2762      : iounit{std::move(i)}, format{std::move(f)}, controls(std::move(cs)),
 
 2763        items(std::move(its)) {}
 
 2764  std::optional<IoUnit> iounit; 
 
 2766  std::optional<Format> format; 
 
 2769  std::list<IoControlSpec> controls;
 
 2770  std::list<InputItem> items;
 
 
 2776  std::variant<Expr, common::Indirection<OutputImpliedDo>> u;
 
 
 2781  BOILERPLATE(WriteStmt);
 
 2782  WriteStmt(std::optional<IoUnit> &&i, std::optional<Format> &&f,
 
 2783      std::list<IoControlSpec> &&cs, std::list<OutputItem> &&its)
 
 2784      : iounit{std::move(i)}, format{std::move(f)}, controls(std::move(cs)),
 
 2785        items(std::move(its)) {}
 
 2786  std::optional<IoUnit> iounit; 
 
 2788  std::optional<Format> format; 
 
 2790  std::list<IoControlSpec> controls;
 
 2791  std::list<OutputItem> items;
 
 
 2797  std::tuple<Format, std::list<OutputItem>> t;
 
 
 2808  std::tuple<std::list<InputItem>, IoImpliedDoControl> t;
 
 
 2813  std::tuple<std::list<OutputItem>, IoImpliedDoControl> t;
 
 
 2820WRAPPER_CLASS(IdExpr, ScalarIntExpr);
 
 2823  std::variant<FileUnitNumber, EndLabel, EorLabel, ErrLabel, IdExpr,
 
 2824      MsgVariable, StatVariable>
 
 
 2829WRAPPER_CLASS(WaitStmt, std::list<WaitSpec>);
 
 2839  std::variant<FileUnitNumber, MsgVariable, StatVariable, ErrLabel> u;
 
 
 2844WRAPPER_CLASS(BackspaceStmt, std::list<PositionOrFlushSpec>);
 
 2848WRAPPER_CLASS(EndfileStmt, std::list<PositionOrFlushSpec>);
 
 2851WRAPPER_CLASS(RewindStmt, std::list<PositionOrFlushSpec>);
 
 2854WRAPPER_CLASS(FlushStmt, std::list<PositionOrFlushSpec>);
 
 2894    ENUM_CLASS(Kind, Access, Action, Asynchronous, Blank, Decimal, Delim,
 
 2895        Direct, Encoding, Form, Formatted, Iomsg, 
Name, Pad, Position, Read,
 
 2896        Readwrite, Round, Sequential, Sign, Stream, Status, Unformatted, Write,
 
 2897         Carriagecontrol, Convert, Dispose)
 
 2898    TUPLE_CLASS_BOILERPLATE(
CharVar);
 
 2899    std::tuple<Kind, ScalarDefaultCharVariable> t;
 
 
 2902    ENUM_CLASS(Kind, Iostat, Nextrec, Number, Pos, Recl, Size)
 
 2903    TUPLE_CLASS_BOILERPLATE(
IntVar);
 
 2904    std::tuple<Kind, ScalarIntVariable> t;
 
 
 2907    ENUM_CLASS(Kind, Exist, Named, Opened, Pending)
 
 2908    TUPLE_CLASS_BOILERPLATE(
LogVar);
 
 2909    std::tuple<Kind, Scalar<Logical<Variable>>> t;
 
 
 
 2923    std::tuple<ScalarIntVariable, std::list<OutputItem>> t;
 
 
 2925  std::variant<std::list<InquireSpec>, 
Iolength> u;
 
 
 2932WRAPPER_CLASS(ProgramStmt, 
Name);
 
 2935WRAPPER_CLASS(EndProgramStmt, std::optional<Name>);
 
 2943      ExecutionPart, std::optional<InternalSubprogramPart>,
 
 
 2949WRAPPER_CLASS(ModuleStmt, 
Name);
 
 2956  std::variant<common::Indirection<FunctionSubprogram>,
 
 
 2966  std::tuple<Statement<ContainsStmt>, std::list<ModuleSubprogram>> t;
 
 
 2970WRAPPER_CLASS(EndModuleStmt, std::optional<Name>);
 
 2976  TUPLE_CLASS_BOILERPLATE(
Module);
 
 
 2987  UNION_CLASS_BOILERPLATE(
Rename);
 
 2989    TUPLE_CLASS_BOILERPLATE(
Names);
 
 2990    std::tuple<Name, Name> t;
 
 
 2994    std::tuple<DefinedOpName, DefinedOpName> t;
 
 
 2996  std::variant<Names, Operators> u;
 
 
 3002  std::tuple<Name, std::optional<Name>> t;
 
 
 3008  std::tuple<ParentIdentifier, Name> t;
 
 
 3012WRAPPER_CLASS(EndSubmoduleStmt, std::optional<Name>);
 
 3025WRAPPER_CLASS(BlockDataStmt, std::optional<Name>);
 
 3028WRAPPER_CLASS(EndBlockDataStmt, std::optional<Name>);
 
 3046  EMPTY_CLASS(Assignment);
 
 3047  EMPTY_CLASS(ReadFormatted);
 
 3048  EMPTY_CLASS(ReadUnformatted);
 
 3049  EMPTY_CLASS(WriteFormatted);
 
 3050  EMPTY_CLASS(WriteUnformatted);
 
 3053      ReadUnformatted, WriteFormatted, WriteUnformatted>
 
 
 3061  std::tuple<std::optional<AccessSpec>, 
GenericSpec, std::list<Name>> t;
 
 
 3065struct InterfaceStmt {
 
 3066  UNION_CLASS_BOILERPLATE(InterfaceStmt);
 
 3068  InterfaceStmt(Abstract x) : u{x} {}
 
 3070  std::variant<std::optional<GenericSpec>, Abstract> u;
 
 
 3076  UNION_CLASS_BOILERPLATE(
Only);
 
 3077  std::variant<common::Indirection<GenericSpec>, 
Name, 
Rename> u;
 
 
 3085  BOILERPLATE(UseStmt);
 
 3086  ENUM_CLASS(ModuleNature, Intrinsic, Non_Intrinsic) 
 
 3087  template <
typename A>
 
 3088  UseStmt(std::optional<ModuleNature> &&nat, 
Name &&n, std::list<A> &&x)
 
 3089      : nature(std::move(nat)), moduleName(std::move(n)), u(std::move(x)) {}
 
 3090  std::optional<ModuleNature> nature;
 
 3092  std::variant<std::list<Rename>, std::list<Only>> u;
 
 
 3110  std::tuple<std::optional<ProcInterface>, std::list<ProcAttrSpec>,
 
 3111      std::list<ProcDecl>>
 
 
 3122  EMPTY_CLASS(Elemental);
 
 3123  EMPTY_CLASS(Impure);
 
 3125  EMPTY_CLASS(Non_Recursive);
 
 3127  EMPTY_CLASS(Recursive);
 
 3128  WRAPPER_CLASS(Attributes, std::list<common::CUDASubprogramAttrs>);
 
 3129  WRAPPER_CLASS(Launch_Bounds, std::list<ScalarIntConstantExpr>);
 
 3130  WRAPPER_CLASS(Cluster_Dims, std::list<ScalarIntConstantExpr>);
 
 3132      Pure, Recursive, Attributes, Launch_Bounds, Cluster_Dims>
 
 
 3140  BOILERPLATE(Suffix);
 
 3142      : binding(std::move(lbs)), resultName(std::move(rn)) {}
 
 3143  Suffix(
Name &&rn, std::optional<LanguageBindingSpec> &&lbs)
 
 3144      : binding(std::move(lbs)), resultName(std::move(rn)) {}
 
 3145  std::optional<LanguageBindingSpec> binding;
 
 3146  std::optional<Name> resultName;
 
 
 3155  std::tuple<std::list<PrefixSpec>, 
Name, std::list<Name>,
 
 3156      std::optional<Suffix>>
 
 
 3161WRAPPER_CLASS(EndFunctionStmt, std::optional<Name>);
 
 3166  std::variant<Name, Star> u;
 
 
 3174  std::tuple<std::list<PrefixSpec>, 
Name, std::list<DummyArg>,
 
 3175      std::optional<LanguageBindingSpec>>
 
 
 3180WRAPPER_CLASS(EndSubroutineStmt, std::optional<Name>);
 
 3195    std::tuple<Statement<SubroutineStmt>,
 
 
 3199  std::variant<Function, Subroutine> u;
 
 
 3204  ENUM_CLASS(Kind, ModuleProcedure, Procedure)
 
 3206  std::tuple<Kind, std::list<Name>> t;
 
 
 3212  std::variant<InterfaceBody, Statement<ProcedureStmt>> u;
 
 
 3216WRAPPER_CLASS(EndInterfaceStmt, std::optional<GenericSpec>);
 
 3222  std::tuple<Statement<InterfaceStmt>, std::list<InterfaceSpecification>,
 
 
 3228WRAPPER_CLASS(ExternalStmt, std::list<Name>);
 
 3231WRAPPER_CLASS(IntrinsicStmt, std::list<Name>);
 
 3237  std::variant<Name, ProcComponentRef> u;
 
 
 3241WRAPPER_CLASS(AltReturnSpec, Label);
 
 3247  WRAPPER_CLASS(PercentRef, 
Expr); 
 
 3248  WRAPPER_CLASS(PercentVal, 
Expr); 
 
 3249  UNION_CLASS_BOILERPLATE(ActualArg);
 
 3251  std::variant<common::Indirection<Expr>, AltReturnSpec, PercentRef, PercentVal>
 
 
 3258  std::tuple<std::optional<Keyword>, 
ActualArg> t;
 
 
 3264  TUPLE_CLASS_BOILERPLATE(
Call);
 
 3265  std::tuple<ProcedureDesignator, std::list<ActualArgSpec>> t;
 
 
 3281  BOILERPLATE(CallStmt);
 
 3282  WRAPPER_CLASS(StarOrExpr, std::optional<ScalarExpr>);
 
 3285    std::tuple<StarOrExpr, ScalarExpr, std::optional<ScalarExpr>,
 
 3286        std::optional<ScalarIntExpr>>
 
 
 3290      std::list<ActualArgSpec> &&args)
 
 3291      : call{std::move(pd), std::move(args)}, chevrons{std::move(ch)} {}
 
 3293  std::optional<Chevrons> chevrons;
 
 
 3320WRAPPER_CLASS(MpSubprogramStmt, 
Name);
 
 3323WRAPPER_CLASS(EndMpSubprogramStmt, std::optional<Name>);
 
 3338  std::tuple<Name, std::list<DummyArg>, std::optional<Suffix>> t;
 
 
 3342WRAPPER_CLASS(ReturnStmt, std::optional<ScalarIntExpr>);
 
 3369    std::tuple<std::optional<std::list<const char *>>, 
Name> t;
 
 
 3372    WRAPPER_CLASS_BOILERPLATE(
LoopCount, std::list<std::uint64_t>);
 
 
 3376    std::tuple<common::Indirection<Designator>, uint64_t> t;
 
 
 3378  EMPTY_CLASS(VectorAlways);
 
 3381    std::tuple<Name, std::optional<std::uint64_t>> t;
 
 
 3384    WRAPPER_CLASS_BOILERPLATE(
Unroll, std::optional<std::uint64_t>);
 
 
 3387    WRAPPER_CLASS_BOILERPLATE(
UnrollAndJam, std::optional<std::uint64_t>);
 
 
 3389  EMPTY_CLASS(NoVector);
 
 3390  EMPTY_CLASS(NoUnroll);
 
 3391  EMPTY_CLASS(NoUnrollAndJam);
 
 3392  EMPTY_CLASS(ForceInline);
 
 3393  EMPTY_CLASS(Inline);
 
 3394  EMPTY_CLASS(NoInline);
 
 3395  EMPTY_CLASS(Unrecognized);
 
 3397  std::variant<std::list<IgnoreTKR>, 
LoopCount, std::list<AssumeAligned>,
 
 3399      NoVector, NoUnroll, NoUnrollAndJam, ForceInline, Inline, NoInline>
 
 
 3406  std::tuple<common::CUDADataAttr, std::list<Name>> t;
 
 
 3412  std::tuple<ObjectName, ObjectName, std::optional<ArraySpec>> t;
 
 
 3414WRAPPER_CLASS(BasedPointerStmt, std::list<BasedPointer>);
 
 3421  std::variant<Statement<DataComponentDefStmt>,
 
 
 3427  EMPTY_CLASS(MapStmt);
 
 3428  EMPTY_CLASS(EndMapStmt);
 
 3429  TUPLE_CLASS_BOILERPLATE(
Map);
 
 3430  std::tuple<Statement<MapStmt>, std::list<StructureField>,
 
 
 3436  EMPTY_CLASS(UnionStmt);
 
 3437  EMPTY_CLASS(EndUnionStmt);
 
 3438  TUPLE_CLASS_BOILERPLATE(
Union);
 
 
 3444  std::tuple<std::optional<Name>, std::list<EntityDecl>> t;
 
 
 3448  EMPTY_CLASS(EndStructureStmt);
 
 3450  std::tuple<Statement<StructureStmt>, std::list<StructureField>,
 
 
 3457WRAPPER_CLASS(OldParameterStmt, std::list<NamedConstantDef>);
 
 3462  std::tuple<Expr, Label, Label, Label> t;
 
 
 3467  std::tuple<Label, Name> t;
 
 
 3472  std::tuple<Name, std::list<Label>> t;
 
 
 3475WRAPPER_CLASS(PauseStmt, std::optional<StopCode>);
 
 3481#define INHERITED_TUPLE_CLASS_BOILERPLATE(classname, basename) \ 
 3482  using basename::basename; \ 
 3483  classname(basename &&b) : basename(std::move(b)) {} \ 
 3484  using TupleTrait = std::true_type; \ 
 3485  BOILERPLATE(classname) 
 3487#define INHERITED_WRAPPER_CLASS_BOILERPLATE(classname, basename) \ 
 3488  BOILERPLATE(classname); \ 
 3489  using basename::basename; \ 
 3490  classname(basename &&base) : basename(std::move(base)) {} \ 
 3491  using WrapperTrait = std::true_type 
 3496struct OmpDirectiveName {
 
 3498  constexpr OmpDirectiveName() = 
default;
 
 3499  constexpr OmpDirectiveName(
const OmpDirectiveName &) = 
default;
 
 3500  constexpr OmpDirectiveName(llvm::omp::Directive x) : v(x) {}
 
 3504  OmpDirectiveName(
const Verbatim &name);
 
 3505  using WrapperTrait = std::true_type;
 
 3507  bool IsExecutionPart() 
const; 
 
 3510  llvm::omp::Directive v{llvm::omp::Directive::OMPD_unknown};
 
 
 3518  std::variant<TypeSpec, DeclarationTypeSpec> u;
 
 
 3533    ENUM_CLASS(Kind, BlankCommonBlock);
 
 3534    WRAPPER_CLASS_BOILERPLATE(
Invalid, Kind);
 
 
 
 3542  WRAPPER_CLASS_BOILERPLATE(
OmpObjectList, std::list<OmpObject>);
 
 
 3549  using EmptyTrait = std::true_type;
 
 
 3557    std::variant<AssignmentStmt, CallStmt, common::Indirection<Expr>> u;
 
 
 3560  std::tuple<std::list<OmpStylizedDeclaration>, 
Instance> t;
 
 
 3574  WRAPPER_CLASS_BOILERPLATE(
 
 
 3587  std::variant<DefinedOperator, ProcedureDesignator> u;
 
 
 3596  INHERITED_WRAPPER_CLASS_BOILERPLATE(
 
 
 3608  INHERITED_WRAPPER_CLASS_BOILERPLATE(
 
 
 3613inline namespace arguments {
 
 3616  std::variant<OmpObject, FunctionReference> u;
 
 
 3620  WRAPPER_CLASS_BOILERPLATE(
OmpLocatorList, std::list<OmpLocator>);
 
 
 3632  std::tuple<OmpObject, OmpObject> t;
 
 
 3643  std::tuple<std::string, TypeSpec, Name> t;
 
 
 3656      std::optional<OmpCombinerExpression>>
 
 
 3675inline namespace traits {
 
 3712    TUPLE_CLASS_BOILERPLATE(
Complex);
 
 3714        std::list<common::Indirection<OmpTraitPropertyExtension>>>
 
 
 3718  std::variant<OmpTraitPropertyName, ScalarExpr, Complex> u;
 
 
 3734  std::variant<OmpTraitPropertyName, common::Indirection<OmpClause>,
 
 
 3759  std::string ToString() 
const;
 
 3762  ENUM_CLASS(Value, Arch, Atomic_Default_Mem_Order, Condition, Device_Num,
 
 3763      Extension, Isa, Kind, Requires, Simd, Uid, Vendor)
 
 3764  std::variant<Value, llvm::omp::Directive, std::string> u;
 
 
 3775    std::tuple<std::optional<OmpTraitScore>, std::list<OmpTraitProperty>> t;
 
 
 3777  std::tuple<OmpTraitSelectorName, std::optional<Properties>> t;
 
 
 3784  std::string ToString() 
const;
 
 3786  ENUM_CLASS(Value, Construct, Device, Implementation, Target_Device, User)
 
 
 3795  std::tuple<OmpTraitSetSelectorName, std::list<OmpTraitSelector>> t;
 
 
 3802  WRAPPER_CLASS_BOILERPLATE(
 
 
 3807#define MODIFIER_BOILERPLATE(...) \ 
 3809    using Variant = std::variant<__VA_ARGS__>; \ 
 3810    UNION_CLASS_BOILERPLATE(Modifier); \ 
 3815#define MODIFIERS() std::optional<std::list<Modifier>> 
 3817inline namespace modifier {
 
 3825  ENUM_CLASS(Value, Cgroup);
 
 
 3834  WRAPPER_CLASS_BOILERPLATE(
OmpAlignment, ScalarIntExpr);
 
 
 3870  ENUM_CLASS(Value, Always)
 
 
 3882  ENUM_CLASS(Value, Always, Never, Auto)
 
 
 3892  ENUM_CLASS(Value, Automap);
 
 
 3903  ENUM_CLASS(Value, Simd)
 
 
 3916  ENUM_CLASS(Value, Close)
 
 
 3928  ENUM_CLASS(Value, Delete)
 
 
 3949  ENUM_CLASS(Value, Sink, Source);
 
 
 3958  ENUM_CLASS(Value, Ancestor, Device_Num)
 
 
 3976  INHERITED_WRAPPER_CLASS_BOILERPLATE(
 
 
 3991  ENUM_CLASS(Value, Present);
 
 
 4001  std::variant<CharLiteralConstant, ScalarIntConstantExpr> u;
 
 
 4009  WRAPPER_CLASS_BOILERPLATE(
 
 
 4018  ENUM_CLASS(Value, Target, TargetSync)
 
 
 4032  std::tuple<TypeDeclarationStmt, SubscriptTriplet> t;
 
 
 4040  WRAPPER_CLASS_BOILERPLATE(
OmpIterator, std::list<OmpIteratorSpecifier>);
 
 
 4048  ENUM_CLASS(Value, Conditional)
 
 
 4057  ENUM_CLASS(Value, Ref, Uval, Val);
 
 
 4079  ENUM_CLASS(Value, Alloc, Delete, From, Release, Storage, To, Tofrom);
 
 4080  WRAPPER_CLASS_BOILERPLATE(
OmpMapType, Value);
 
 
 4092  ENUM_CLASS(Value, Always, Close, Present, Ompx_Hold)
 
 
 4107  ENUM_CLASS(Value, Monotonic, Nonmonotonic, Simd)
 
 
 4116  ENUM_CLASS(Value, Reproducible, Unconstrained)
 
 
 4126  ENUM_CLASS(Value, Strict, Fallback)
 
 
 4139  ENUM_CLASS(Value, Present)
 
 
 4148  ENUM_CLASS(Value, Default, Inscan, Task);
 
 
 4158  ENUM_CLASS(Value, Ref_Ptee, Ref_Ptr, Ref_Ptr_Ptee)
 
 
 4168  ENUM_CLASS(Value, Self)
 
 
 4195  ENUM_CLASS(Value, In, Out, Inout, Inoutset, Mutexinoutset, Depobj)
 
 
 4206  ENUM_CLASS(Value, Aggregate, All, Allocatable, Pointer, 
Scalar)
 
 
 4219  ENUM_CLASS(Value, Ompx_Hold)
 
 
 4229using OmpDirectiveList = std::list<llvm::omp::Directive>;
 
 4242    ENUM_CLASS(Value, Nothing, Need_Device_Ptr)
 
 
 4245  std::tuple<OmpAdjustOp, OmpObjectList> t;
 
 
 4262  WRAPPER_CLASS_BOILERPLATE(
OmpAlignClause, ScalarIntConstantExpr);
 
 
 4293    WRAPPER_CLASS_BOILERPLATE(
OmpAppendOp, std::list<OmpInteropType>);
 
 
 
 4301  ENUM_CLASS(ActionTime, Compilation, Execution);
 
 4302  WRAPPER_CLASS_BOILERPLATE(
OmpAtClause, ActionTime);
 
 
 4313  using MemoryOrder = common::OmpMemoryOrderType;
 
 
 4324  ENUM_CLASS(Binding, Parallel, Teams, Thread)
 
 
 4331  std::tuple<OmpDirectiveName, std::optional<ScalarLogicalExpr>> t;
 
 
 4356  ENUM_CLASS(DataSharingAttribute, Private, Firstprivate, Shared, None)
 
 4358  std::variant<DataSharingAttribute,
 
 
 4375  ENUM_CLASS(ImplicitBehavior, Alloc, To, From, Tofrom, Firstprivate, None,
 
 4378  std::tuple<ImplicitBehavior, MODIFIERS()> t;
 
 
 4387  std::tuple<DefinedOperator, ScalarIntConstantExpr> t;
 
 
 4396  std::tuple<Name, std::optional<OmpIterationOffset>> t;
 
 
 4413  OmpDependenceType::Value GetDepType() 
const;
 
 4416  EMPTY_CLASS(Source);
 
 4418  std::variant<Sink, Source> u;
 
 
 4433    OmpTaskDependenceType::Value GetTaskDepType() 
const;
 
 4434    TUPLE_CLASS_BOILERPLATE(
TaskDep);
 
 
 4438  std::variant<TaskDep, OmpDoacross> u;
 
 
 4475  std::tuple<MODIFIERS(), ScalarIntExpr> t;
 
 
 4491  ENUM_CLASS(DeviceTypeDescription, Any, Host, Nohost)
 
 
 4501  WRAPPER_CLASS_BOILERPLATE(
 
 
 4508  std::tuple<MODIFIERS(), ScalarIntExpr> t;
 
 
 4525  using MemoryOrder = common::OmpMemoryOrderType;
 
 
 4551  std::tuple<MODIFIERS(), ScalarIntExpr> t;
 
 
 4572  WRAPPER_CLASS_BOILERPLATE(
OmpHintClause, ScalarIntConstantExpr);
 
 
 4585  WRAPPER_CLASS_BOILERPLATE(
 
 
 4598  std::tuple<MODIFIERS(), ScalarLogicalExpr> t;
 
 
 4638  MODIFIER_BOILERPLATE(
 
 
 4649  std::tuple<ScalarIntConstantExpr, ScalarIntConstantExpr> t;
 
 
 4686  WRAPPER_CLASS_BOILERPLATE(
 
 
 4700EMPTY_CLASS(OmpNoOpenMPClause);
 
 4705EMPTY_CLASS(OmpNoOpenMPRoutinesClause);
 
 4710EMPTY_CLASS(OmpNoParallelismClause);
 
 4720  std::tuple<MODIFIERS(), ScalarIntExpr> t;
 
 
 4730  ENUM_CLASS(Ordering, Concurrent)
 
 4732  std::tuple<MODIFIERS(), Ordering> t;
 
 
 4754  ENUM_CLASS(AffinityPolicy, Close, Master, Spread, Primary)
 
 
 4797  ENUM_CLASS(Kind, Static, Dynamic, Guided, Auto, Runtime)
 
 4799  std::tuple<MODIFIERS(), Kind, std::optional<ScalarIntExpr>> t;
 
 
 4814  ENUM_CLASS(Severity, Fatal, Warning);
 
 
 4832  ENUM_CLASS(ThreadsetPolicy, Omp_Pool, Omp_Team)
 
 
 4875  WRAPPER_CLASS_BOILERPLATE(
 
 
 4893  std::variant<OmpDependenceType, OmpTaskDependenceType> u;
 
 
 4903  MODIFIER_BOILERPLATE(OmpContextSelector);
 
 4904  std::tuple<MODIFIERS(),
 
 4905      std::optional<common::Indirection<OmpDirectiveSpecification>>>
 
 
 4933  llvm::omp::Clause Id() 
const;
 
 4935#define GEN_FLANG_CLAUSE_PARSER_CLASSES 
 4936#include "llvm/Frontend/OpenMP/OMP.inc" 
 4941#define GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST 
 4942#include "llvm/Frontend/OpenMP/OMP.inc" 
 
 4948  WRAPPER_CLASS_BOILERPLATE(
OmpClauseList, std::list<OmpClause>);
 
 
 4955  ENUM_CLASS(Flags, None, DeprecatedSyntax);
 
 4958    return std::get<OmpDirectiveName>(t);
 
 4960  llvm::omp::Directive DirId()
 const { 
 
 4967  std::tuple<OmpDirectiveName, std::optional<OmpArgumentList>,
 
 4968      std::optional<OmpClauseList>, Flags>
 
 
 4977  INHERITED_TUPLE_CLASS_BOILERPLATE(
 
 
 4989    return std::get<OmpBeginDirective>(t);
 
 4991  const std::optional<OmpEndDirective> &EndDir()
 const {
 
 4992    return std::get<std::optional<OmpEndDirective>>(t);
 
 4996  std::tuple<OmpBeginDirective, Block, std::optional<OmpEndDirective>> t;
 
 
 5000  WRAPPER_CLASS_BOILERPLATE(
 
 
 5021  std::variant<OmpErrorDirective, OmpNothingDirective> u;
 
 
 5030  WRAPPER_CLASS_BOILERPLATE(
 
 
 5048  INHERITED_TUPLE_CLASS_BOILERPLATE(
 
 
 5063  std::tuple<std::optional<OmpDirectiveSpecification>, Block> t;
 
 
 5071    return std::get<OmpBeginSectionsDirective>(t);
 
 5073  const std::optional<OmpEndSectionsDirective> &EndDir()
 const {
 
 5074    return std::get<std::optional<OmpEndSectionsDirective>>(t);
 
 5081  std::tuple<OmpBeginSectionsDirective, std::list<OpenMPConstruct>,
 
 5082      std::optional<OmpEndSectionsDirective>>
 
 
 5091  WRAPPER_CLASS_BOILERPLATE(
 
 
 5103  WRAPPER_CLASS_BOILERPLATE(
 
 
 5111  WRAPPER_CLASS_BOILERPLATE(
 
 
 5120  WRAPPER_CLASS_BOILERPLATE(
 
 
 5128  WRAPPER_CLASS_BOILERPLATE(
 
 
 5158  std::tuple<Verbatim, OmpObjectList, OmpClauseList> t;
 
 
 5184  std::tuple<Verbatim, std::optional<OmpObjectList>, 
OmpClauseList,
 
 5185      std::optional<std::list<OpenMPDeclarativeAllocate>>,
 
 
 5197  INHERITED_TUPLE_CLASS_BOILERPLATE(
 
 
 5202  llvm::omp::Clause GetKind() 
const;
 
 5203  bool IsCapture() 
const;
 
 5204  bool IsCompare() 
const;
 
 5210    static constexpr int None = 0;
 
 5211    static constexpr int Read = 1;
 
 5212    static constexpr int Write = 2;
 
 5213    static constexpr int Update = Read | Write;
 
 5214    static constexpr int Action = 3; 
 
 5215    static constexpr int IfTrue = 4;
 
 5216    static constexpr int IfFalse = 8;
 
 5217    static constexpr int Condition = 12; 
 
 5221      AssignmentStmt::TypedAssignment assign;
 
 
 5223    TypedExpr atom, cond;
 
 
 
 5232  WRAPPER_CLASS_BOILERPLATE(
 
 
 5293  WRAPPER_CLASS_BOILERPLATE(
 
 
 5316using NestedConstruct =
 
 5317    std::variant<DoConstruct, common::Indirection<OpenMPLoopConstruct>>;
 
 5318struct OpenMPLoopConstruct {
 
 5319  TUPLE_CLASS_BOILERPLATE(OpenMPLoopConstruct);
 
 5321      : t({std::move(a), std::nullopt, std::nullopt}) {}
 
 5324    return std::get<OmpBeginLoopDirective>(t);
 
 5326  const std::optional<OmpEndLoopDirective> &EndDir()
 const {
 
 5327    return std::get<std::optional<OmpEndLoopDirective>>(t);
 
 5329  std::tuple<OmpBeginLoopDirective, std::optional<NestedConstruct>,
 
 5330      std::optional<OmpEndLoopDirective>>
 
 
 5358WRAPPER_CLASS(AccObjectList, std::list<AccObject>);
 
 5390  std::variant<Name, ScalarDefaultCharExpr> u;
 
 
 5400  ENUM_CLASS(Modifier, ReadOnly, Zero)
 
 
 5407  std::tuple<std::optional<AccDataModifier>, AccObjectList> t;
 
 
 5412  std::tuple<ReductionOperator, AccObjectList> t;
 
 
 5417  std::tuple<std::optional<ScalarIntExpr>, std::list<ScalarIntExpr>> t;
 
 
 5421  WRAPPER_CLASS_BOILERPLATE(
 
 
 5427  WRAPPER_CLASS_BOILERPLATE(
 
 
 5434  std::tuple<std::optional<ScalarIntConstantExpr>> t; 
 
 
 5442  WRAPPER_CLASS_BOILERPLATE(
AccSizeExpr, std::optional<ScalarIntExpr>);
 
 
 5451  std::variant<std::optional<ScalarLogicalExpr>, AccObjectList> u;
 
 
 5458  WRAPPER_CLASS(Num, ScalarIntExpr);
 
 5459  WRAPPER_CLASS(Dim, ScalarIntExpr);
 
 5461  std::variant<Num, Dim, Static> u;
 
 
 5466  WRAPPER_CLASS_BOILERPLATE(
AccGangArgList, std::list<AccGangArg>);
 
 
 5471  std::tuple<bool, ScalarIntConstantExpr> t;
 
 
 5477#define GEN_FLANG_CLAUSE_PARSER_CLASSES 
 5478#include "llvm/Frontend/OpenACC/ACC.inc" 
 5483#define GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST 
 5484#include "llvm/Frontend/OpenACC/ACC.inc" 
 
 5490  WRAPPER_CLASS_BOILERPLATE(
AccClauseList, std::list<AccClause>);
 
 
 5503  std::tuple<Verbatim, AccObjectListWithModifier> t;
 
 
 5509  std::tuple<Verbatim, std::optional<AccWaitArgument>, 
AccClauseList> t;
 
 
 5514  std::tuple<AccLoopDirective, AccClauseList> t;
 
 
 5521  std::tuple<AccBlockDirective, AccClauseList> t;
 
 
 5530EMPTY_CLASS(AccEndAtomic);
 
 5535  std::tuple<Verbatim, AccClauseList, Statement<AssignmentStmt>,
 
 5536      std::optional<AccEndAtomic>>
 
 
 5543  std::tuple<Verbatim, AccClauseList, Statement<AssignmentStmt>,
 
 5544      std::optional<AccEndAtomic>>
 
 
 5552      std::optional<AccEndAtomic>>
 
 
 5561  std::tuple<Verbatim, AccClauseList, Stmt1, Stmt2, AccEndAtomic> t;
 
 
 5566  std::variant<AccAtomicRead, AccAtomicWrite, AccAtomicCapture, AccAtomicUpdate>
 
 
 5573  std::tuple<AccBeginBlockDirective, Block, AccEndBlockDirective> t;
 
 
 5579  std::tuple<AccDeclarativeDirective, AccClauseList> t;
 
 
 5585  std::tuple<AccCombinedDirective, AccClauseList> t;
 
 
 5593struct OpenACCCombinedConstruct {
 
 5594  TUPLE_CLASS_BOILERPLATE(OpenACCCombinedConstruct);
 
 5597      : t({std::move(a), std::nullopt, std::nullopt}) {}
 
 5598  std::tuple<AccBeginCombinedDirective, std::optional<DoConstruct>,
 
 5599      std::optional<AccEndCombinedDirective>>
 
 
 5606  std::variant<OpenACCStandaloneDeclarativeConstruct, OpenACCRoutineConstruct>
 
 
 5611EMPTY_CLASS(AccEndLoop);
 
 5612struct OpenACCLoopConstruct {
 
 5613  TUPLE_CLASS_BOILERPLATE(OpenACCLoopConstruct);
 
 5615      : t({std::move(a), std::nullopt, std::nullopt}) {}
 
 5616  std::tuple<AccBeginLoopDirective, std::optional<DoConstruct>,
 
 5617      std::optional<AccEndLoop>>
 
 
 5629  std::tuple<AccStandaloneDirective, AccClauseList> t;
 
 
 5655  std::tuple<Operator, std::list<Scalar<Variable>>> t;
 
 
 5660  WRAPPER_CLASS(StarOrExpr, std::optional<ScalarIntExpr>);
 
 5663    std::tuple<std::list<StarOrExpr>, std::list<StarOrExpr>,
 
 5664        std::optional<ScalarIntExpr>>
 
 
 5670    std::tuple<std::optional<ScalarIntConstantExpr>,
 
 5671        std::optional<LaunchConfiguration>, std::list<CUFReduction>>
 
 
 5674  std::tuple<Directive, std::optional<DoConstruct>> t;
 
 
Definition indirection.h:127
Definition indirection.h:31
Definition reference.h:18
Definition char-block.h:28
Definition parse-state.h:35
Definition check-expression.h:19
Definition expression.h:906
Definition expression.h:896
Definition parse-tree.h:1306
Definition parse-tree.h:1313
Definition parse-tree.h:1272
Definition parse-tree.h:1261
Definition parse-tree.h:1260
Definition parse-tree.h:5557
Definition parse-tree.h:5533
Definition parse-tree.h:5549
Definition parse-tree.h:5541
Definition parse-tree.h:5518
Definition parse-tree.h:5582
Definition parse-tree.h:5512
Definition parse-tree.h:5388
Definition parse-tree.h:5361
Definition parse-tree.h:5489
Definition parse-tree.h:5474
Definition parse-tree.h:5469
Definition parse-tree.h:5377
Definition parse-tree.h:5399
Definition parse-tree.h:5382
Definition parse-tree.h:5394
Definition parse-tree.h:5426
Definition parse-tree.h:5420
Definition parse-tree.h:5524
Definition parse-tree.h:5588
Definition parse-tree.h:5465
Definition parse-tree.h:5456
Definition parse-tree.h:5366
Definition parse-tree.h:5405
Definition parse-tree.h:5410
Definition parse-tree.h:5353
Definition parse-tree.h:5449
Definition parse-tree.h:5445
Definition parse-tree.h:5441
Definition parse-tree.h:5371
Definition parse-tree.h:5437
Definition parse-tree.h:5431
Definition parse-tree.h:5415
Definition parse-tree.h:912
Definition parse-tree.h:1430
Definition parse-tree.h:493
Definition parse-tree.h:3256
Definition parse-tree.h:3246
Definition parse-tree.h:1983
Definition parse-tree.h:1948
Definition parse-tree.h:1927
Definition parse-tree.h:1939
Definition parse-tree.h:1994
Definition parse-tree.h:1956
Definition parse-tree.h:3460
Definition parse-tree.h:1915
Definition parse-tree.h:1361
Definition parse-tree.h:3465
Definition parse-tree.h:3470
Definition parse-tree.h:2020
Definition parse-tree.h:2177
Definition parse-tree.h:2168
Definition parse-tree.h:2161
Definition parse-tree.h:1343
Definition parse-tree.h:1391
Definition parse-tree.h:3410
Definition parse-tree.h:1130
Definition parse-tree.h:1452
Definition parse-tree.h:1459
Definition parse-tree.h:2199
Definition parse-tree.h:3031
Definition parse-tree.h:2032
Definition parse-tree.h:3404
Definition parse-tree.h:5667
Definition parse-tree.h:5661
Definition parse-tree.h:5658
Definition parse-tree.h:5652
Definition parse-tree.h:3283
Definition parse-tree.h:3280
Definition parse-tree.h:3263
Definition parse-tree.h:2442
Definition parse-tree.h:2441
Definition parse-tree.h:2423
Definition parse-tree.h:2429
Definition parse-tree.h:2409
Definition parse-tree.h:2230
Definition parse-tree.h:2215
Definition parse-tree.h:666
Definition parse-tree.h:1844
Definition parse-tree.h:871
Definition parse-tree.h:684
Definition parse-tree.h:682
Definition parse-tree.h:2700
Definition parse-tree.h:2699
Definition parse-tree.h:2207
Definition parse-tree.h:987
Definition parse-tree.h:1465
Definition parse-tree.h:1906
Definition parse-tree.h:1629
Definition parse-tree.h:1638
Definition parse-tree.h:1637
Definition parse-tree.h:3374
Definition parse-tree.h:3367
Definition parse-tree.h:3371
Definition parse-tree.h:3379
Definition parse-tree.h:3386
Definition parse-tree.h:3383
Definition parse-tree.h:3365
Definition parse-tree.h:857
Definition parse-tree.h:849
Definition parse-tree.h:998
Definition parse-tree.h:1011
Definition parse-tree.h:1119
Definition parse-tree.h:1064
Definition parse-tree.h:1223
Definition parse-tree.h:2528
Definition parse-tree.h:2255
Definition parse-tree.h:2677
Definition parse-tree.h:2675
Definition parse-tree.h:302
Definition parse-tree.h:2246
Definition parse-tree.h:2237
Definition parse-tree.h:1072
Definition parse-tree.h:1519
Definition parse-tree.h:1531
Definition parse-tree.h:1822
Definition parse-tree.h:1490
Definition parse-tree.h:1539
Definition parse-tree.h:1505
Definition parse-tree.h:1545
Definition parse-tree.h:1511
Definition parse-tree.h:2014
Definition parse-tree.h:434
Definition parse-tree.h:778
Definition parse-tree.h:773
Definition parse-tree.h:771
Definition parse-tree.h:326
Definition parse-tree.h:608
Definition parse-tree.h:1208
Definition parse-tree.h:753
Definition parse-tree.h:929
Definition parse-tree.h:1861
Definition parse-tree.h:1557
Definition parse-tree.h:1556
Definition parse-tree.h:2342
Definition parse-tree.h:3164
Definition parse-tree.h:2362
Definition parse-tree.h:2224
Definition parse-tree.h:1406
Definition parse-tree.h:3336
Definition parse-tree.h:1252
Definition parse-tree.h:1238
Definition parse-tree.h:2582
Definition parse-tree.h:2588
Definition parse-tree.h:2596
Definition parse-tree.h:526
Definition parse-tree.h:550
Definition parse-tree.h:981
Definition parse-tree.h:968
Definition parse-tree.h:1768
Definition parse-tree.h:1741
Definition parse-tree.h:1782
Definition parse-tree.h:1747
Definition parse-tree.h:1786
Definition parse-tree.h:1723
Definition parse-tree.h:1738
Definition parse-tree.h:1774
Definition parse-tree.h:1756
Definition parse-tree.h:1762
Definition parse-tree.h:1765
Definition parse-tree.h:1728
Definition parse-tree.h:1753
Definition parse-tree.h:1750
Definition parse-tree.h:1735
Definition parse-tree.h:1777
Definition parse-tree.h:1759
Definition parse-tree.h:1717
Definition parse-tree.h:1714
Definition parse-tree.h:1771
Definition parse-tree.h:1708
Definition parse-tree.h:1732
Definition parse-tree.h:1744
Definition parse-tree.h:1711
Definition parse-tree.h:1704
Definition parse-tree.h:1058
Definition parse-tree.h:2118
Definition parse-tree.h:2134
Definition parse-tree.h:2112
Definition parse-tree.h:2147
Definition parse-tree.h:2124
Definition parse-tree.h:3268
Definition parse-tree.h:3153
Definition parse-tree.h:3302
Definition parse-tree.h:3044
Definition parse-tree.h:3059
Definition parse-tree.h:878
Definition parse-tree.h:2381
Definition parse-tree.h:2377
Definition parse-tree.h:2376
Definition parse-tree.h:2392
Definition parse-tree.h:2355
Definition parse-tree.h:1689
Definition parse-tree.h:1698
Definition parse-tree.h:416
Definition parse-tree.h:1613
Definition parse-tree.h:1622
Definition parse-tree.h:621
Definition parse-tree.h:1029
Definition parse-tree.h:2893
Definition parse-tree.h:2901
Definition parse-tree.h:2906
Definition parse-tree.h:2891
Definition parse-tree.h:2921
Definition parse-tree.h:2919
Definition parse-tree.h:805
Definition parse-tree.h:310
Definition parse-tree.h:1369
Definition parse-tree.h:1565
Definition parse-tree.h:3220
Definition parse-tree.h:3187
Definition parse-tree.h:3193
Definition parse-tree.h:3185
Definition parse-tree.h:3210
Definition parse-tree.h:472
Definition parse-tree.h:460
Definition parse-tree.h:716
Definition parse-tree.h:711
Definition parse-tree.h:721
Definition parse-tree.h:705
Definition parse-tree.h:703
Definition parse-tree.h:2735
Definition parse-tree.h:2733
Definition parse-tree.h:2647
Definition parse-tree.h:792
Definition parse-tree.h:654
Definition parse-tree.h:2319
Definition parse-tree.h:1322
Definition parse-tree.h:672
Definition parse-tree.h:1607
Definition parse-tree.h:903
Definition parse-tree.h:2291
Definition parse-tree.h:2287
Definition parse-tree.h:2623
Definition parse-tree.h:2622
Definition parse-tree.h:885
Definition parse-tree.h:318
Definition parse-tree.h:1287
Definition parse-tree.h:2309
Definition parse-tree.h:2307
Definition parse-tree.h:2940
Definition parse-tree.h:3426
Definition parse-tree.h:2079
Definition parse-tree.h:2964
Definition parse-tree.h:2954
Definition parse-tree.h:2975
Definition parse-tree.h:583
Definition parse-tree.h:1328
Definition parse-tree.h:635
Definition parse-tree.h:634
Definition parse-tree.h:2325
Definition parse-tree.h:2550
Definition parse-tree.h:1439
Definition parse-tree.h:4235
Definition parse-tree.h:4241
Definition parse-tree.h:4239
Definition parse-tree.h:4254
Definition parse-tree.h:4261
Definition parse-tree.h:4269
Definition parse-tree.h:4284
Definition parse-tree.h:4292
Definition parse-tree.h:4291
Definition parse-tree.h:4300
Definition parse-tree.h:4312
Definition parse-tree.h:4976
Definition parse-tree.h:5307
Definition parse-tree.h:5047
Definition parse-tree.h:4323
Definition parse-tree.h:4986
Definition parse-tree.h:4329
Definition parse-tree.h:4947
Definition parse-tree.h:4931
Definition parse-tree.h:3595
Definition parse-tree.h:4338
Definition parse-tree.h:5090
Definition parse-tree.h:4355
Definition parse-tree.h:4373
Definition parse-tree.h:4432
Definition parse-tree.h:4430
Definition parse-tree.h:4454
Definition parse-tree.h:4462
Definition parse-tree.h:4472
Definition parse-tree.h:4482
Definition parse-tree.h:4490
Definition parse-tree.h:3496
Definition parse-tree.h:4954
Definition parse-tree.h:4445
Definition parse-tree.h:4412
Definition parse-tree.h:4505
Definition parse-tree.h:4500
Definition parse-tree.h:4981
Definition parse-tree.h:5311
Definition parse-tree.h:5052
Definition parse-tree.h:4516
Definition parse-tree.h:5014
Definition parse-tree.h:4524
Definition parse-tree.h:4537
Definition parse-tree.h:4548
Definition parse-tree.h:4558
Definition parse-tree.h:4566
Definition parse-tree.h:4571
Definition parse-tree.h:4579
Definition parse-tree.h:4595
Definition parse-tree.h:4605
Definition parse-tree.h:4584
Definition parse-tree.h:4917
Definition parse-tree.h:4612
Definition parse-tree.h:3607
Definition parse-tree.h:4385
Definition parse-tree.h:4403
Definition parse-tree.h:4394
Definition parse-tree.h:4621
Definition parse-tree.h:4636
Definition parse-tree.h:4647
Definition parse-tree.h:4672
Definition parse-tree.h:4684
Definition parse-tree.h:4693
Definition parse-tree.h:5008
Definition parse-tree.h:4717
Definition parse-tree.h:3541
Definition parse-tree.h:3532
Definition parse-tree.h:3529
Definition parse-tree.h:4728
Definition parse-tree.h:4741
Definition parse-tree.h:4753
Definition parse-tree.h:4764
Definition parse-tree.h:3585
Definition parse-tree.h:4774
Definition parse-tree.h:4783
Definition parse-tree.h:4795
Definition parse-tree.h:4806
Definition parse-tree.h:4813
Definition parse-tree.h:3545
Definition parse-tree.h:3567
Definition parse-tree.h:3555
Definition parse-tree.h:3554
Definition parse-tree.h:4822
Definition parse-tree.h:4831
Definition parse-tree.h:4846
Definition parse-tree.h:4856
Definition parse-tree.h:3521
Definition parse-tree.h:3514
Definition parse-tree.h:4865
Definition parse-tree.h:4874
Definition parse-tree.h:4890
Definition parse-tree.h:4926
Definition parse-tree.h:4901
Definition parse-tree.h:3075
Definition parse-tree.h:5564
Definition parse-tree.h:5571
Definition parse-tree.h:5500
Definition parse-tree.h:5593
Definition parse-tree.h:5632
Definition parse-tree.h:5603
Definition parse-tree.h:5621
Definition parse-tree.h:5612
Definition parse-tree.h:5494
Definition parse-tree.h:5626
Definition parse-tree.h:5576
Definition parse-tree.h:5506
Definition parse-tree.h:5196
Definition parse-tree.h:5041
Definition parse-tree.h:5219
Definition parse-tree.h:5209
Definition parse-tree.h:5201
Definition parse-tree.h:5238
Definition parse-tree.h:5231
Definition parse-tree.h:5341
Definition parse-tree.h:5173
Definition parse-tree.h:5155
Definition parse-tree.h:5029
Definition parse-tree.h:5161
Definition parse-tree.h:5110
Definition parse-tree.h:5119
Definition parse-tree.h:5127
Definition parse-tree.h:5102
Definition parse-tree.h:5249
Definition parse-tree.h:5263
Definition parse-tree.h:5336
Definition parse-tree.h:5181
Definition parse-tree.h:5279
Definition parse-tree.h:5137
Definition parse-tree.h:5287
Definition parse-tree.h:5318
Definition parse-tree.h:5143
Definition parse-tree.h:5061
Definition parse-tree.h:5067
Definition parse-tree.h:5292
Definition parse-tree.h:5298
Definition parse-tree.h:5149
Definition parse-tree.h:5018
Definition parse-tree.h:375
Definition parse-tree.h:2811
Definition parse-tree.h:2774
Definition parse-tree.h:3000
Definition parse-tree.h:2045
Definition parse-tree.h:2044
Definition parse-tree.h:1575
Definition parse-tree.h:2003
Definition parse-tree.h:2837
Definition parse-tree.h:3120
Definition parse-tree.h:2795
Definition parse-tree.h:942
Definition parse-tree.h:3098
Definition parse-tree.h:1083
Definition parse-tree.h:1111
Definition parse-tree.h:1901
Definition parse-tree.h:1103
Definition parse-tree.h:1097
Definition parse-tree.h:1090
Definition parse-tree.h:3108
Definition parse-tree.h:3235
Definition parse-tree.h:3203
Definition parse-tree.h:567
Definition parse-tree.h:2758
Definition parse-tree.h:826
Definition parse-tree.h:824
Definition parse-tree.h:2276
Definition parse-tree.h:2988
Definition parse-tree.h:2992
Definition parse-tree.h:2986
Definition parse-tree.h:1588
Definition parse-tree.h:294
Definition parse-tree.h:1675
Definition parse-tree.h:2399
Definition parse-tree.h:2465
Definition parse-tree.h:2464
Definition parse-tree.h:2478
Definition parse-tree.h:2476
Definition parse-tree.h:2455
Definition parse-tree.h:2512
Definition parse-tree.h:2510
Definition parse-tree.h:2490
Definition parse-tree.h:2155
Definition parse-tree.h:3328
Definition parse-tree.h:863
Definition parse-tree.h:798
Definition parse-tree.h:838
Definition parse-tree.h:397
Definition parse-tree.h:448
Definition parse-tree.h:1972
Definition parse-tree.h:358
Definition parse-tree.h:3346
Definition parse-tree.h:2542
Definition parse-tree.h:1891
Definition parse-tree.h:1229
Definition parse-tree.h:3447
Definition parse-tree.h:3419
Definition parse-tree.h:3442
Definition parse-tree.h:3006
Definition parse-tree.h:3017
Definition parse-tree.h:3172
Definition parse-tree.h:3312
Definition parse-tree.h:1666
Definition parse-tree.h:1853
Definition parse-tree.h:1657
Definition parse-tree.h:1839
Definition parse-tree.h:2561
Definition parse-tree.h:2560
Definition parse-tree.h:2573
Definition parse-tree.h:920
Definition parse-tree.h:1172
Definition parse-tree.h:1185
Definition parse-tree.h:1138
Definition parse-tree.h:1194
Definition parse-tree.h:1148
Definition parse-tree.h:1420
Definition parse-tree.h:2500
Definition parse-tree.h:2499
Definition parse-tree.h:948
Definition parse-tree.h:956
Definition parse-tree.h:747
Definition parse-tree.h:645
Definition parse-tree.h:760
Definition parse-tree.h:3435
Definition parse-tree.h:353
Definition parse-tree.h:2632
Definition parse-tree.h:811
Definition parse-tree.h:3084
Definition parse-tree.h:1869
Definition parse-tree.h:733
Definition parse-tree.h:738
Definition parse-tree.h:281
Definition parse-tree.h:2821
Definition parse-tree.h:2070
Definition parse-tree.h:2063
Definition parse-tree.h:2099
Definition parse-tree.h:2095
Definition parse-tree.h:2094
Definition parse-tree.h:2057
Definition parse-tree.h:2780
Definition parse-tree.h:3669
Definition parse-tree.h:3660
Definition parse-tree.h:3630
Definition parse-tree.h:3619
Definition parse-tree.h:3614
Definition parse-tree.h:3640
Definition parse-tree.h:3653
Definition parse-tree.h:3824
Definition parse-tree.h:3841
Definition parse-tree.h:3833
Definition parse-tree.h:3857
Definition parse-tree.h:3849
Definition parse-tree.h:3869
Definition parse-tree.h:3881
Definition parse-tree.h:3891
Definition parse-tree.h:3902
Definition parse-tree.h:3915
Definition parse-tree.h:3927
Definition parse-tree.h:3948
Definition parse-tree.h:3957
Definition parse-tree.h:3975
Definition parse-tree.h:3990
Definition parse-tree.h:4008
Definition parse-tree.h:3999
Definition parse-tree.h:4017
Definition parse-tree.h:4029
Definition parse-tree.h:4039
Definition parse-tree.h:4047
Definition parse-tree.h:4056
Definition parse-tree.h:4091
Definition parse-tree.h:4078
Definition parse-tree.h:4065
Definition parse-tree.h:4115
Definition parse-tree.h:4106
Definition parse-tree.h:4125
Definition parse-tree.h:4138
Definition parse-tree.h:4147
Definition parse-tree.h:4157
Definition parse-tree.h:4167
Definition parse-tree.h:4176
Definition parse-tree.h:4184
Definition parse-tree.h:4194
Definition parse-tree.h:4205
Definition parse-tree.h:4218
Definition parse-tree.h:3800
Definition parse-tree.h:3710
Definition parse-tree.h:3707
Definition parse-tree.h:3690
Definition parse-tree.h:3731
Definition parse-tree.h:3697
Definition parse-tree.h:3758
Definition parse-tree.h:3773
Definition parse-tree.h:3770
Definition parse-tree.h:3783
Definition parse-tree.h:3792