Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

 

 

 

namespace llvm {

 

class FoldingSetNodeID;

 

} // namespace llvm

 

namespace clang {

 

class ASTContext;

class Attr;

class CapturedDecl;

class Decl;

class Expr;

class AddrLabelExpr;

class LabelDecl;

class ODRHash;

class PrinterHelper;

struct PrintingPolicy;

class RecordDecl;

class SourceManager;

class StringLiteral;

class Token;

class VarDecl;

 

 

class alignas(void *) Stmt {

  enum StmtClass {

    NoStmtClass = 0,

  };

 

  // Make vanilla 'new' and 'delete' illegal for Stmts.

  friend class ASTStmtReader;

  friend class ASTStmtWriter;

 

  void *operator new(size_t bytes) noexcept {

    llvm_unreachable("Stmts cannot be allocated with regular 'new'.");

  }

 

  void operator delete(void *data) noexcept {

    llvm_unreachable("Stmts cannot be released with regular 'delete'.");

  }

 

  //===--- Statement bitfields classes ---===//

 

  class StmtBitfields {

    friend class ASTStmtReader;

    friend class ASTStmtWriter;

    friend class Stmt;

 

    /// The statement class.

    unsigned sClass : 8;

  };

  enum { NumStmtBits = 8 };

 

  class NullStmtBitfields {

    friend class ASTStmtReader;

    friend class ASTStmtWriter;

    friend class NullStmt;

 

    unsigned : NumStmtBits;

 

    /// True if the null statement was preceded by an empty macro, e.g:

    /// @code

    ///   #define CALL(x)

    ///   CALL(0);

    /// @endcode

    unsigned HasLeadingEmptyMacro : 1;

 

    /// The location of the semi-colon.

    SourceLocation SemiLoc;

  };

 

  class CompoundStmtBitfields {

    friend class ASTStmtReader;

    friend class CompoundStmt;

 

    unsigned : NumStmtBits;

 

    /// True if the compound statement has one or more pragmas that set some

    /// floating-point features.

    unsigned HasFPFeatures : 1;

 

    unsigned NumStmts;

  };

 

  class LabelStmtBitfields {

    friend class LabelStmt;

 

    unsigned : NumStmtBits;

 

    SourceLocation IdentLoc;

  };

 

  class AttributedStmtBitfields {

    friend class ASTStmtReader;

    friend class AttributedStmt;

 

    unsigned : NumStmtBits;

 

    /// Number of attributes.

    unsigned NumAttrs : 32 - NumStmtBits;

 

    /// The location of the attribute.

    SourceLocation AttrLoc;

  };

 

  class IfStmtBitfields {

    friend class ASTStmtReader;

    friend class IfStmt;

 

    unsigned : NumStmtBits;

 

    /// Whether this is a constexpr if, or a consteval if, or neither.

    unsigned Kind : 3;

 

    /// True if this if statement has storage for an else statement.

    unsigned HasElse : 1;

 

    /// True if this if statement has storage for a variable declaration.

    unsigned HasVar : 1;

 

    /// True if this if statement has storage for an init statement.

    unsigned HasInit : 1;

 

    /// The location of the "if".

    SourceLocation IfLoc;

  };

 

  class SwitchStmtBitfields {

    friend class SwitchStmt;

 

    unsigned : NumStmtBits;

 

    /// True if the SwitchStmt has storage for an init statement.

    unsigned HasInit : 1;

 

    /// True if the SwitchStmt has storage for a condition variable.

    unsigned HasVar : 1;

 

    /// If the SwitchStmt is a switch on an enum value, records whether all

    /// the enum values were covered by CaseStmts.  The coverage information

    /// value is meant to be a hint for possible clients.

    unsigned AllEnumCasesCovered : 1;

 

    /// The location of the "switch".

    SourceLocation SwitchLoc;

  };

 

  class WhileStmtBitfields {

    friend class ASTStmtReader;

    friend class WhileStmt;

 

    unsigned : NumStmtBits;

 

    /// True if the WhileStmt has storage for a condition variable.

    unsigned HasVar : 1;

 

    /// The location of the "while".

    SourceLocation WhileLoc;

  };

 

  class DoStmtBitfields {

    friend class DoStmt;

 

    unsigned : NumStmtBits;

 

    /// The location of the "do".

    SourceLocation DoLoc;

  };

 

  class ForStmtBitfields {

    friend class ForStmt;

 

    unsigned : NumStmtBits;

 

    /// The location of the "for".

    SourceLocation ForLoc;

  };

 

  class GotoStmtBitfields {

    friend class GotoStmt;

    friend class IndirectGotoStmt;

 

    unsigned : NumStmtBits;

 

    /// The location of the "goto".

    SourceLocation GotoLoc;

  };

 

  class ContinueStmtBitfields {

    friend class ContinueStmt;

 

    unsigned : NumStmtBits;

 

    /// The location of the "continue".

    SourceLocation ContinueLoc;

  };

 

  class BreakStmtBitfields {

    friend class BreakStmt;

 

    unsigned : NumStmtBits;

 

    /// The location of the "break".

    SourceLocation BreakLoc;

  };

 

  class ReturnStmtBitfields {

    friend class ReturnStmt;

 

    unsigned : NumStmtBits;

 

    /// True if this ReturnStmt has storage for an NRVO candidate.

    unsigned HasNRVOCandidate : 1;

 

    /// The location of the "return".

    SourceLocation RetLoc;

  };

 

  class SwitchCaseBitfields {

    friend class SwitchCase;

    friend class CaseStmt;

 

    unsigned : NumStmtBits;

 

    /// Used by CaseStmt to store whether it is a case statement

    /// of the form case LHS ... RHS (a GNU extension).

    unsigned CaseStmtIsGNURange : 1;

 

    /// The location of the "case" or "default" keyword.

    SourceLocation KeywordLoc;

  };

 

  //===--- Expression bitfields classes ---===//

 

  class ExprBitfields {

    friend class ASTStmtReader; // deserialization

    friend class AtomicExpr; // ctor

    friend class BlockDeclRefExpr; // ctor

    friend class CallExpr; // ctor

    friend class CXXConstructExpr; // ctor

    friend class CXXDependentScopeMemberExpr; // ctor

    friend class CXXNewExpr; // ctor

    friend class CXXUnresolvedConstructExpr; // ctor

    friend class DeclRefExpr; // computeDependence

    friend class DependentScopeDeclRefExpr; // ctor

    friend class DesignatedInitExpr; // ctor

    friend class Expr;

    friend class InitListExpr; // ctor

    friend class ObjCArrayLiteral; // ctor

    friend class ObjCDictionaryLiteral; // ctor

    friend class ObjCMessageExpr; // ctor

    friend class OffsetOfExpr; // ctor

    friend class OpaqueValueExpr; // ctor

    friend class OverloadExpr; // ctor

    friend class ParenListExpr; // ctor

    friend class PseudoObjectExpr; // ctor

    friend class ShuffleVectorExpr; // ctor

 

    unsigned : NumStmtBits;

 

    unsigned ValueKind : 2;

    unsigned ObjectKind : 3;

    unsigned /*ExprDependence*/ Dependent : llvm::BitWidth<ExprDependence>;

  };

  enum { NumExprBits = NumStmtBits + 5 + llvm::BitWidth<ExprDependence> };

 

  class ConstantExprBitfields {

    friend class ASTStmtReader;

    friend class ASTStmtWriter;

    friend class ConstantExpr;

 

    unsigned : NumExprBits;

 

    /// The kind of result that is tail-allocated.

    unsigned ResultKind : 2;

 

    /// The kind of Result as defined by APValue::Kind.

    unsigned APValueKind : 4;

 

    /// When ResultKind == RSK_Int64, true if the tail-allocated integer is

    /// unsigned.

    unsigned IsUnsigned : 1;

 

    /// When ResultKind == RSK_Int64. the BitWidth of the tail-allocated

    /// integer. 7 bits because it is the minimal number of bits to represent a

    /// value from 0 to 64 (the size of the tail-allocated integer).

    unsigned BitWidth : 7;

 

    /// When ResultKind == RSK_APValue, true if the ASTContext will cleanup the

    /// tail-allocated APValue.

    unsigned HasCleanup : 1;

 

    /// True if this ConstantExpr was created for immediate invocation.

    unsigned IsImmediateInvocation : 1;

  };

 

  class PredefinedExprBitfields {

    friend class ASTStmtReader;

    friend class PredefinedExpr;

 

    unsigned : NumExprBits;

 

    /// The kind of this PredefinedExpr. One of the enumeration values

    /// in PredefinedExpr::IdentKind.

    unsigned Kind : 4;

 

    /// True if this PredefinedExpr has a trailing "StringLiteral *"

    /// for the predefined identifier.

    unsigned HasFunctionName : 1;

 

    /// The location of this PredefinedExpr.

    SourceLocation Loc;

  };

 

  class DeclRefExprBitfields {

    friend class ASTStmtReader; // deserialization

    friend class DeclRefExpr;

 

    unsigned : NumExprBits;

 

    unsigned HasQualifier : 1;

    unsigned HasTemplateKWAndArgsInfo : 1;

    unsigned HasFoundDecl : 1;

    unsigned HadMultipleCandidates : 1;

    unsigned RefersToEnclosingVariableOrCapture : 1;

    unsigned NonOdrUseReason : 2;

 

    /// The location of the declaration name itself.

    SourceLocation Loc;

  };

 

 

  class FloatingLiteralBitfields {

    friend class FloatingLiteral;

 

    unsigned : NumExprBits;

 

    static_assert(

        llvm::APFloat::S_MaxSemantics < 16,

        "Too many Semantics enum values to fit in bitfield of size 4");

    unsigned Semantics : 4; // Provides semantics for APFloat construction

    unsigned IsExact : 1;

  };

 

  class StringLiteralBitfields {

    friend class ASTStmtReader;

    friend class StringLiteral;

 

    unsigned : NumExprBits;

 

    /// The kind of this string literal.

    /// One of the enumeration values of StringLiteral::StringKind.

    unsigned Kind : 3;

 

    /// The width of a single character in bytes. Only values of 1, 2,

    /// and 4 bytes are supported. StringLiteral::mapCharByteWidth maps

    /// the target + string kind to the appropriate CharByteWidth.

    unsigned CharByteWidth : 3;

 

    unsigned IsPascal : 1;

 

    /// The number of concatenated token this string is made of.

    /// This is the number of trailing SourceLocation.

    unsigned NumConcatenated;

  };

 

  class CharacterLiteralBitfields {

    friend class CharacterLiteral;

 

    unsigned : NumExprBits;

 

    unsigned Kind : 3;

  };

 

  class UnaryOperatorBitfields {

    friend class UnaryOperator;

 

    unsigned : NumExprBits;

 

    unsigned Opc : 5;

    unsigned CanOverflow : 1;

    //

    /// This is only meaningful for operations on floating point

    /// types when additional values need to be in trailing storage.

    /// It is 0 otherwise.

    unsigned HasFPFeatures : 1;

 

    SourceLocation Loc;

  };

 

  class UnaryExprOrTypeTraitExprBitfields {

    friend class UnaryExprOrTypeTraitExpr;

 

    unsigned : NumExprBits;

 

    unsigned Kind : 3;

    unsigned IsType : 1; // true if operand is a type, false if an expression.

  };

 

  class ArrayOrMatrixSubscriptExprBitfields {

    friend class ArraySubscriptExpr;

    friend class MatrixSubscriptExpr;

 

    unsigned : NumExprBits;

 

    SourceLocation RBracketLoc;

  };

 

  class CallExprBitfields {

    friend class CallExpr;

 

    unsigned : NumExprBits;

 

    unsigned NumPreArgs : 1;

 

    /// True if the callee of the call expression was found using ADL.

    unsigned UsesADL : 1;

 

    /// True if the call expression has some floating-point features.

    unsigned HasFPFeatures : 1;

 

    /// Padding used to align OffsetToTrailingObjects to a byte multiple.

    unsigned : 24 - 3 - NumExprBits;

 

    /// The offset in bytes from the this pointer to the start of the

    /// trailing objects belonging to CallExpr. Intentionally byte sized

    /// for faster access.

    unsigned OffsetToTrailingObjects : 8;

  };

  enum { NumCallExprBits = 32 };

 

  class MemberExprBitfields {

    friend class ASTStmtReader;

    friend class MemberExpr;

 

    unsigned : NumExprBits;

 

    /// IsArrow - True if this is "X->F", false if this is "X.F".

    unsigned IsArrow : 1;

 

    /// True if this member expression used a nested-name-specifier to

    /// refer to the member, e.g., "x->Base::f", or found its member via

    /// a using declaration.  When true, a MemberExprNameQualifier

    /// structure is allocated immediately after the MemberExpr.

    unsigned HasQualifierOrFoundDecl : 1;

 

    /// True if this member expression specified a template keyword

    /// and/or a template argument list explicitly, e.g., x->f<int>,

    /// x->template f, x->template f<int>.

    /// When true, an ASTTemplateKWAndArgsInfo structure and its

    /// TemplateArguments (if any) are present.

    unsigned HasTemplateKWAndArgsInfo : 1;

 

    /// True if this member expression refers to a method that

    /// was resolved from an overloaded set having size greater than 1.

    unsigned HadMultipleCandidates : 1;

 

    /// Value of type NonOdrUseReason indicating why this MemberExpr does

    /// not constitute an odr-use of the named declaration. Meaningful only

    /// when naming a static member.

    unsigned NonOdrUseReason : 2;

 

    /// This is the location of the -> or . in the expression.

    SourceLocation OperatorLoc;

  };

 

  class CastExprBitfields {

    friend class CastExpr;

    friend class ImplicitCastExpr;

 

    unsigned : NumExprBits;

 

    unsigned Kind : 7;

    unsigned PartOfExplicitCast : 1; // Only set for ImplicitCastExpr.

 

    /// True if the call expression has some floating-point features.

    unsigned HasFPFeatures : 1;

 

    /// The number of CXXBaseSpecifiers in the cast. 14 bits would be enough

    /// here. ([implimits] Direct and indirect base classes [16384]).

    unsigned BasePathSize;

  };

 

  class BinaryOperatorBitfields {

    friend class BinaryOperator;

 

    unsigned : NumExprBits;

 

    unsigned Opc : 6;

 

    /// This is only meaningful for operations on floating point

    /// types when additional values need to be in trailing storage.

    /// It is 0 otherwise.

    unsigned HasFPFeatures : 1;

 

    SourceLocation OpLoc;

  };

 

  class InitListExprBitfields {

    friend class InitListExpr;

 

    unsigned : NumExprBits;

 

    /// Whether this initializer list originally had a GNU array-range

    /// designator in it. This is a temporary marker used by CodeGen.

    unsigned HadArrayRangeDesignator : 1;

  };

 

  class ParenListExprBitfields {

    friend class ASTStmtReader;

    friend class ParenListExpr;

 

    unsigned : NumExprBits;

 

    /// The number of expressions in the paren list.

    unsigned NumExprs;

  };

 

  class GenericSelectionExprBitfields {

    friend class ASTStmtReader;

    friend class GenericSelectionExpr;

 

    unsigned : NumExprBits;

 

    /// The location of the "_Generic".

    SourceLocation GenericLoc;

  };

 

  class PseudoObjectExprBitfields {

    friend class ASTStmtReader; // deserialization

    friend class PseudoObjectExpr;

 

    unsigned : NumExprBits;

 

    // These don't need to be particularly wide, because they're

    // strictly limited by the forms of expressions we permit.

    unsigned NumSubExprs : 8;

    unsigned ResultIndex : 32 - 8 - NumExprBits;

  };

 

  class SourceLocExprBitfields {

    friend class ASTStmtReader;

    friend class SourceLocExpr;

 

    unsigned : NumExprBits;

 

    /// The kind of source location builtin represented by the SourceLocExpr.

    /// Ex. __builtin_LINE, __builtin_FUNCTION, etc.

    unsigned Kind : 3;

  };

 

  class StmtExprBitfields {

    friend class ASTStmtReader;

    friend class StmtExpr;

 

    unsigned : NumExprBits;

 

    /// The number of levels of template parameters enclosing this statement

    /// expression. Used to determine if a statement expression remains

    /// dependent after instantiation.

    unsigned TemplateDepth;

  };

 

  //===--- C++ Expression bitfields classes ---===//

 

  class CXXOperatorCallExprBitfields {

    friend class ASTStmtReader;

    friend class CXXOperatorCallExpr;

 

    unsigned : NumCallExprBits;

 

    /// The kind of this overloaded operator. One of the enumerator

    /// value of OverloadedOperatorKind.

    unsigned OperatorKind : 6;

  };

 

  class CXXRewrittenBinaryOperatorBitfields {

    friend class ASTStmtReader;

    friend class CXXRewrittenBinaryOperator;

 

    unsigned : NumCallExprBits;

 

    unsigned IsReversed : 1;

  };

 

  class CXXBoolLiteralExprBitfields {

    friend class CXXBoolLiteralExpr;

 

    unsigned : NumExprBits;

 

    /// The value of the boolean literal.

    unsigned Value : 1;

 

    /// The location of the boolean literal.

    SourceLocation Loc;

  };

 

  class CXXNullPtrLiteralExprBitfields {

    friend class CXXNullPtrLiteralExpr;

 

    unsigned : NumExprBits;

 

    /// The location of the null pointer literal.

    SourceLocation Loc;

  };

 

  class CXXThisExprBitfields {

    friend class CXXThisExpr;

 

    unsigned : NumExprBits;

 

    /// Whether this is an implicit "this".

    unsigned IsImplicit : 1;

 

    /// The location of the "this".

    SourceLocation Loc;

  };

 

  class CXXThrowExprBitfields {

    friend class ASTStmtReader;

    friend class CXXThrowExpr;

 

    unsigned : NumExprBits;

 

    /// Whether the thrown variable (if any) is in scope.

    unsigned IsThrownVariableInScope : 1;

 

    /// The location of the "throw".

    SourceLocation ThrowLoc;

  };

 

  class CXXDefaultArgExprBitfields {

    friend class ASTStmtReader;

    friend class CXXDefaultArgExpr;

 

    unsigned : NumExprBits;

 

    /// Whether this CXXDefaultArgExpr rewrote its argument and stores a copy.

    unsigned HasRewrittenInit : 1;

 

    /// The location where the default argument expression was used.

    SourceLocation Loc;

  };

 

  class CXXDefaultInitExprBitfields {

    friend class ASTStmtReader;

    friend class CXXDefaultInitExpr;

 

    unsigned : NumExprBits;

 

    /// Whether this CXXDefaultInitExprBitfields rewrote its argument and stores

    /// a copy.

    unsigned HasRewrittenInit : 1;

 

    /// The location where the default initializer expression was used.

    SourceLocation Loc;

  };

 

  class CXXScalarValueInitExprBitfields {

    friend class ASTStmtReader;

    friend class CXXScalarValueInitExpr;

 

    unsigned : NumExprBits;

 

    SourceLocation RParenLoc;

  };

 

  class CXXNewExprBitfields {

    friend class ASTStmtReader;

    friend class ASTStmtWriter;

    friend class CXXNewExpr;

 

    unsigned : NumExprBits;

 

    /// Was the usage ::new, i.e. is the global new to be used?

    unsigned IsGlobalNew : 1;

 

    /// Do we allocate an array? If so, the first trailing "Stmt *" is the

    /// size expression.

    unsigned IsArray : 1;

 

    /// Should the alignment be passed to the allocation function?

    unsigned ShouldPassAlignment : 1;

 

    /// If this is an array allocation, does the usual deallocation

    /// function for the allocated type want to know the allocated size?

    unsigned UsualArrayDeleteWantsSize : 1;

 

    /// What kind of initializer do we have? Could be none, parens, or braces.

    /// In storage, we distinguish between "none, and no initializer expr", and

    /// "none, but an implicit initializer expr".

    unsigned StoredInitializationStyle : 2;

 

    /// True if the allocated type was expressed as a parenthesized type-id.

    unsigned IsParenTypeId : 1;

 

    /// The number of placement new arguments.

    unsigned NumPlacementArgs;

  };

 

  class CXXDeleteExprBitfields {

    friend class ASTStmtReader;

    friend class CXXDeleteExpr;

 

    unsigned : NumExprBits;

 

    /// Is this a forced global delete, i.e. "::delete"?

    unsigned GlobalDelete : 1;

 

    /// Is this the array form of delete, i.e. "delete[]"?

    unsigned ArrayForm : 1;

 

    /// ArrayFormAsWritten can be different from ArrayForm if 'delete' is

    /// applied to pointer-to-array type (ArrayFormAsWritten will be false

    /// while ArrayForm will be true).

    unsigned ArrayFormAsWritten : 1;

 

    /// Does the usual deallocation function for the element type require

    /// a size_t argument?

    unsigned UsualArrayDeleteWantsSize : 1;

 

    /// Location of the expression.

    SourceLocation Loc;

  };

 

  class TypeTraitExprBitfields {

    friend class ASTStmtReader;

    friend class ASTStmtWriter;

    friend class TypeTraitExpr;

 

    unsigned : NumExprBits;

 

    /// The kind of type trait, which is a value of a TypeTrait enumerator.

    unsigned Kind : 8;

 

    /// If this expression is not value-dependent, this indicates whether

    /// the trait evaluated true or false.

    unsigned Value : 1;

 

    /// The number of arguments to this type trait. According to [implimits]

    /// 8 bits would be enough, but we require (and test for) at least 16 bits

    /// to mirror FunctionType.

    unsigned NumArgs;

  };

 

  class DependentScopeDeclRefExprBitfields {

    friend class ASTStmtReader;

    friend class ASTStmtWriter;

    friend class DependentScopeDeclRefExpr;

 

    unsigned : NumExprBits;

 

    /// Whether the name includes info for explicit template

    /// keyword and arguments.

    unsigned HasTemplateKWAndArgsInfo : 1;

  };

 

  class CXXConstructExprBitfields {

    friend class ASTStmtReader;

    friend class CXXConstructExpr;

 

    unsigned : NumExprBits;

 

    unsigned Elidable : 1;

    unsigned HadMultipleCandidates : 1;

    unsigned ListInitialization : 1;

    unsigned StdInitListInitialization : 1;

    unsigned ZeroInitialization : 1;

    unsigned ConstructionKind : 3;

 

    SourceLocation Loc;

  };

 

  class ExprWithCleanupsBitfields {

    friend class ASTStmtReader; // deserialization

    friend class ExprWithCleanups;

 

    unsigned : NumExprBits;

 

    // When false, it must not have side effects.

    unsigned CleanupsHaveSideEffects : 1;

 

    unsigned NumObjects : 32 - 1 - NumExprBits;

  };

 

  class CXXUnresolvedConstructExprBitfields {

    friend class ASTStmtReader;

    friend class CXXUnresolvedConstructExpr;

 

    unsigned : NumExprBits;

 

    /// The number of arguments used to construct the type.

    unsigned NumArgs;

  };

 

  class CXXDependentScopeMemberExprBitfields {

    friend class ASTStmtReader;

    friend class CXXDependentScopeMemberExpr;

 

    unsigned : NumExprBits;

 

    /// Whether this member expression used the '->' operator or

    /// the '.' operator.

    unsigned IsArrow : 1;

 

    /// Whether this member expression has info for explicit template

    /// keyword and arguments.

    unsigned HasTemplateKWAndArgsInfo : 1;

 

    /// See getFirstQualifierFoundInScope() and the comment listing

    /// the trailing objects.

    unsigned HasFirstQualifierFoundInScope : 1;

 

    /// The location of the '->' or '.' operator.

    SourceLocation OperatorLoc;

  };

 

  class OverloadExprBitfields {

    friend class ASTStmtReader;

    friend class OverloadExpr;

 

    unsigned : NumExprBits;

 

    /// Whether the name includes info for explicit template

    /// keyword and arguments.

    unsigned HasTemplateKWAndArgsInfo : 1;

 

    /// Padding used by the derived classes to store various bits. If you

    /// need to add some data here, shrink this padding and add your data

    /// above. NumOverloadExprBits also needs to be updated.

    unsigned : 32 - NumExprBits - 1;

 

    /// The number of results.

    unsigned NumResults;

  };

  enum { NumOverloadExprBits = NumExprBits + 1 };

 

  class UnresolvedLookupExprBitfields {

    friend class ASTStmtReader;

    friend class UnresolvedLookupExpr;

 

    unsigned : NumOverloadExprBits;

 

    /// True if these lookup results should be extended by

    /// argument-dependent lookup if this is the operand of a function call.

    unsigned RequiresADL : 1;

 

    /// True if these lookup results are overloaded.  This is pretty trivially

    /// rederivable if we urgently need to kill this field.

    unsigned Overloaded : 1;

  };

  static_assert(sizeof(UnresolvedLookupExprBitfields) <= 4,

                "UnresolvedLookupExprBitfields must be <= than 4 bytes to"

                "avoid trashing OverloadExprBitfields::NumResults!");

 

  class UnresolvedMemberExprBitfields {

    friend class ASTStmtReader;

    friend class UnresolvedMemberExpr;

 

    unsigned : NumOverloadExprBits;

 

    /// Whether this member expression used the '->' operator or

    /// the '.' operator.

    unsigned IsArrow : 1;

 

    /// Whether the lookup results contain an unresolved using declaration.

    unsigned HasUnresolvedUsing : 1;

  };

  static_assert(sizeof(UnresolvedMemberExprBitfields) <= 4,

                "UnresolvedMemberExprBitfields must be <= than 4 bytes to"

                "avoid trashing OverloadExprBitfields::NumResults!");

 

  class CXXNoexceptExprBitfields {

    friend class ASTStmtReader;

    friend class CXXNoexceptExpr;

 

    unsigned : NumExprBits;

 

    unsigned Value : 1;

  };

 

  class SubstNonTypeTemplateParmExprBitfields {

    friend class ASTStmtReader;

    friend class SubstNonTypeTemplateParmExpr;

 

    unsigned : NumExprBits;

 

    /// The location of the non-type template parameter reference.

    SourceLocation NameLoc;

  };

 

  class LambdaExprBitfields {

    friend class ASTStmtReader;

    friend class ASTStmtWriter;

    friend class LambdaExpr;

 

    unsigned : NumExprBits;

 

    /// The default capture kind, which is a value of type

    /// LambdaCaptureDefault.

    unsigned CaptureDefault : 2;

 

    /// Whether this lambda had an explicit parameter list vs. an

    /// implicit (and empty) parameter list.

    unsigned ExplicitParams : 1;

 

    /// Whether this lambda had the result type explicitly specified.

    unsigned ExplicitResultType : 1;

 

    /// The number of captures.

    unsigned NumCaptures : 16;

  };

 

  class RequiresExprBitfields {

    friend class ASTStmtReader;

    friend class ASTStmtWriter;

    friend class RequiresExpr;

 

    unsigned : NumExprBits;

 

    unsigned IsSatisfied : 1;

    SourceLocation RequiresKWLoc;

  };

 

  //===--- C++ Coroutines TS bitfields classes ---===//

 

  class CoawaitExprBitfields {

    friend class CoawaitExpr;

 

    unsigned : NumExprBits;

 

    unsigned IsImplicit : 1;

  };

 

  //===--- Obj-C Expression bitfields classes ---===//

 

  class ObjCIndirectCopyRestoreExprBitfields {

    friend class ObjCIndirectCopyRestoreExpr;

 

    unsigned : NumExprBits;

 

    unsigned ShouldCopy : 1;

  };

 

  //===--- Clang Extensions bitfields classes ---===//

 

  class OpaqueValueExprBitfields {

    friend class ASTStmtReader;

    friend class OpaqueValueExpr;

 

    unsigned : NumExprBits;

 

    /// The OVE is a unique semantic reference to its source expression if this

    /// bit is set to true.

    unsigned IsUnique : 1;

 

    SourceLocation Loc;

  };

 

  union {

    // Same order as in StmtNodes.td.

    // Statements

    StmtBitfields StmtBits;

    NullStmtBitfields NullStmtBits;

    CompoundStmtBitfields CompoundStmtBits;

    LabelStmtBitfields LabelStmtBits;

    AttributedStmtBitfields AttributedStmtBits;

    IfStmtBitfields IfStmtBits;

    SwitchStmtBitfields SwitchStmtBits;

    WhileStmtBitfields WhileStmtBits;

    DoStmtBitfields DoStmtBits;

    ForStmtBitfields ForStmtBits;

    GotoStmtBitfields GotoStmtBits;

    ContinueStmtBitfields ContinueStmtBits;

    BreakStmtBitfields BreakStmtBits;

    ReturnStmtBitfields ReturnStmtBits;

    SwitchCaseBitfields SwitchCaseBits;

 

    // Expressions

    ExprBitfields ExprBits;

    ConstantExprBitfields ConstantExprBits;

    PredefinedExprBitfields PredefinedExprBits;

    DeclRefExprBitfields DeclRefExprBits;

    FloatingLiteralBitfields FloatingLiteralBits;

    StringLiteralBitfields StringLiteralBits;

    CharacterLiteralBitfields CharacterLiteralBits;

    UnaryOperatorBitfields UnaryOperatorBits;

    UnaryExprOrTypeTraitExprBitfields UnaryExprOrTypeTraitExprBits;

    ArrayOrMatrixSubscriptExprBitfields ArrayOrMatrixSubscriptExprBits;

    CallExprBitfields CallExprBits;

    MemberExprBitfields MemberExprBits;

    CastExprBitfields CastExprBits;

    BinaryOperatorBitfields BinaryOperatorBits;

    InitListExprBitfields InitListExprBits;

    ParenListExprBitfields ParenListExprBits;

    GenericSelectionExprBitfields GenericSelectionExprBits;

    PseudoObjectExprBitfields PseudoObjectExprBits;

    SourceLocExprBitfields SourceLocExprBits;

 

    // GNU Extensions.

    StmtExprBitfields StmtExprBits;

 

    // C++ Expressions

    CXXOperatorCallExprBitfields CXXOperatorCallExprBits;

    CXXRewrittenBinaryOperatorBitfields CXXRewrittenBinaryOperatorBits;

    CXXBoolLiteralExprBitfields CXXBoolLiteralExprBits;

    CXXNullPtrLiteralExprBitfields CXXNullPtrLiteralExprBits;

    CXXThisExprBitfields CXXThisExprBits;

    CXXThrowExprBitfields CXXThrowExprBits;

    CXXDefaultArgExprBitfields CXXDefaultArgExprBits;

    CXXDefaultInitExprBitfields CXXDefaultInitExprBits;

    CXXScalarValueInitExprBitfields CXXScalarValueInitExprBits;

    CXXNewExprBitfields CXXNewExprBits;

    CXXDeleteExprBitfields CXXDeleteExprBits;

    TypeTraitExprBitfields TypeTraitExprBits;

    DependentScopeDeclRefExprBitfields DependentScopeDeclRefExprBits;

    CXXConstructExprBitfields CXXConstructExprBits;

    ExprWithCleanupsBitfields ExprWithCleanupsBits;

    CXXUnresolvedConstructExprBitfields CXXUnresolvedConstructExprBits;

    CXXDependentScopeMemberExprBitfields CXXDependentScopeMemberExprBits;

    OverloadExprBitfields OverloadExprBits;

    UnresolvedLookupExprBitfields UnresolvedLookupExprBits;

    UnresolvedMemberExprBitfields UnresolvedMemberExprBits;

    CXXNoexceptExprBitfields CXXNoexceptExprBits;

    SubstNonTypeTemplateParmExprBitfields SubstNonTypeTemplateParmExprBits;

    LambdaExprBitfields LambdaExprBits;

    RequiresExprBitfields RequiresExprBits;

 

    // C++ Coroutines TS expressions

    CoawaitExprBitfields CoawaitBits;

 

    // Obj-C Expressions

    ObjCIndirectCopyRestoreExprBitfields ObjCIndirectCopyRestoreExprBits;

 

    // Clang Extensions

    OpaqueValueExprBitfields OpaqueValueExprBits;

  };

 

  // Only allow allocation of Stmts using the allocator in ASTContext

  // or by doing a placement new.

  void* operator new(size_t bytes, const ASTContext& C,

                     unsigned alignment = 8);

 

  void* operator new(size_t bytes, const ASTContext* C,

                     unsigned alignment = 8) {

    return operator new(bytes, *C, alignment);

  }

 

  void *operator new(size_t bytes, void *mem) noexcept { return mem; }

 

  void operator delete(void *, const ASTContext &, unsigned) noexcept {}

  void operator delete(void *, const ASTContext *, unsigned) noexcept {}

  void operator delete(void *, size_t) noexcept {}

  void operator delete(void *, void *) noexcept {}

 

  /// A placeholder type used to construct an empty shell of a

  /// type, that will be filled in later (e.g., by some

  /// de-serialization).

  struct EmptyShell {};

 

  /// The likelihood of a branch being taken.

  enum Likelihood {

    LH_Unlikely = -1, ///< Branch has the [[unlikely]] attribute.

    LH_None,          ///< No attribute set or branches of the IfStmt have

                      ///< the same attribute.

    LH_Likely         ///< Branch has the [[likely]] attribute.

  };

 

  /// Iterator for iterating over Stmt * arrays that contain only T *.

  ///

  /// This is needed because AST nodes use Stmt* arrays to store

  /// references to children (to be compatible with StmtIterator).

  template<typename T, typename TPtr = T *, typename StmtPtr = Stmt *>

  struct CastIterator

      : llvm::iterator_adaptor_base<CastIterator<T, TPtr, StmtPtr>, StmtPtr *,

                                    std::random_access_iterator_tag, TPtr> {

    using Base = typename CastIterator::iterator_adaptor_base;

 

    CastIterator() : Base(nullptr) {}

    CastIterator(StmtPtr *I) : Base(I) {}

 

    typename Base::value_type operator*() const {

      return cast_or_null<T>(*this->I);

    }

  };

 

  /// Const iterator for iterating over Stmt * arrays that contain only T *.

  template <typename T>

  using ConstCastIterator = CastIterator<T, const T *const, const Stmt *const>;

 

  using ExprIterator = CastIterator<Expr>;

  using ConstExprIterator = ConstCastIterator<Expr>;

 

  /// Whether statistic collection is enabled.

  static bool StatisticsEnabled;

 

  /// Construct an empty statement.

  explicit Stmt(StmtClass SC, EmptyShell) : Stmt(SC) {}

 

  Stmt() = delete;

  Stmt(const Stmt &) = delete;

  Stmt(Stmt &&) = delete;

  Stmt &operator=(const Stmt &) = delete;

  Stmt &operator=(Stmt &&) = delete;

 

  Stmt(StmtClass SC) {

    static_assert(sizeof(*this) <= 8,

                  "changing bitfields changed sizeof(Stmt)");

    static_assert(sizeof(*this) % alignof(void *) == 0,

                  "Insufficient alignment!");

    StmtBits.sClass = SC;

    if (StatisticsEnabled) Stmt::addStmtClass(SC);

  }

 

  StmtClass getStmtClass() const {

    return static_cast<StmtClass>(StmtBits.sClass);

  }

 

  const char *getStmtClassName() const;

 

  /// SourceLocation tokens are not useful in isolation - they are low level

  /// value objects created/interpreted by SourceManager. We assume AST

  /// clients will have a pointer to the respective SourceManager.

  SourceRange getSourceRange() const LLVM_READONLY;

  SourceLocation getBeginLoc() const LLVM_READONLY;

  SourceLocation getEndLoc() const LLVM_READONLY;

 

  // global temp stats (until we have a per-module visitor)

  static void addStmtClass(const StmtClass s);

  static void EnableStatistics();

  static void PrintStats();

 

  /// \returns the likelihood of a set of attributes.

  static Likelihood getLikelihood(ArrayRef<const Attr *> Attrs);

 

  /// \returns the likelihood of a statement.

  static Likelihood getLikelihood(const Stmt *S);

 

  /// \returns the likelihood attribute of a statement.

  static const Attr *getLikelihoodAttr(const Stmt *S);

 

  /// \returns the likelihood of the 'then' branch of an 'if' statement. The

  /// 'else' branch is required to determine whether both branches specify the

  /// same likelihood, which affects the result.

  static Likelihood getLikelihood(const Stmt *Then, const Stmt *Else);

 

  /// \returns whether the likelihood of the branches of an if statement are

  /// conflicting. When the first element is \c true there's a conflict and

  /// the Attr's are the conflicting attributes of the Then and Else Stmt.

  static std::tuple<bool, const Attr *, const Attr *>

  determineLikelihoodConflict(const Stmt *Then, const Stmt *Else);

 

  /// Dumps the specified AST fragment and all subtrees to

  /// \c llvm::errs().

  void dump() const;

  void dump(raw_ostream &OS, const ASTContext &Context) const;

 

  /// \return Unique reproducible object identifier

  int64_t getID(const ASTContext &Context) const;

 

  /// dumpColor - same as dump(), but forces color highlighting.

  void dumpColor() const;

 

  /// dumpPretty/printPretty - These two methods do a "pretty print" of the AST

  /// back to its original source language syntax.

  void dumpPretty(const ASTContext &Context) const;

  void printPretty(raw_ostream &OS, PrinterHelper *Helper,

                   const PrintingPolicy &Policy, unsigned Indentation = 0,

                   StringRef NewlineSymbol = "\n",

                   const ASTContext *Context = nullptr) const;

  void printPrettyControlled(raw_ostream &OS, PrinterHelper *Helper,

                             const PrintingPolicy &Policy,

                             unsigned Indentation = 0,

                             StringRef NewlineSymbol = "\n",

                             const ASTContext *Context = nullptr) const;

 

  /// Pretty-prints in JSON format.

  void printJson(raw_ostream &Out, PrinterHelper *Helper,

                 const PrintingPolicy &Policy, bool AddQuotes) const;

 

  /// viewAST - Visualize an AST rooted at this Stmt* using GraphViz.  Only

  ///   works on systems with GraphViz (Mac OS X) or dot+gv installed.

  void viewAST() const;

 

  /// Skip no-op (attributed, compound) container stmts and skip captured

  /// stmt at the top, if \a IgnoreCaptured is true.

  Stmt *IgnoreContainers(bool IgnoreCaptured = false);

  const Stmt *IgnoreContainers(bool IgnoreCaptured = false) const {

    return const_cast<Stmt *>(this)->IgnoreContainers(IgnoreCaptured);

  }

 

  const Stmt *stripLabelLikeStatements() const;

  Stmt *stripLabelLikeStatements() {

    return const_cast<Stmt*>(

      const_cast<const Stmt*>(this)->stripLabelLikeStatements());

  }

 

  /// Child Iterators: All subclasses must implement 'children'

  /// to permit easy iteration over the substatements/subexpressions of an

  /// AST node.  This permits easy iteration over all nodes in the AST.

  using child_iterator = StmtIterator;

  using const_child_iterator = ConstStmtIterator;

 

  using child_range = llvm::iterator_range<child_iterator>;

  using const_child_range = llvm::iterator_range<const_child_iterator>;

 

  child_range children();

 

  const_child_range children() const {

    auto Children = const_cast<Stmt *>(this)->children();

    return const_child_range(Children.begin(), Children.end());

  }

 

  child_iterator child_begin() { return children().begin(); }

  child_iterator child_end() { return children().end(); }

 

  const_child_iterator child_begin() const { return children().begin(); }

  const_child_iterator child_end() const { return children().end(); }

 

  /// Produce a unique representation of the given statement.

  ///

  /// \param ID once the profiling operation is complete, will contain

  /// the unique representation of the given statement.

  ///

  /// \param Context the AST context in which the statement resides

  ///

  /// \param Canonical whether the profile should be based on the canonical

  /// representation of this statement (e.g., where non-type template

  /// parameters are identified by index/level rather than their

  /// declaration pointers) or the exact representation of the statement as

  /// written in the source.

  void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,

               bool Canonical) const;

 

  /// Calculate a unique representation for a statement that is

  /// stable across compiler invocations.

  ///

  /// \param ID profile information will be stored in ID.

  ///

  /// \param Hash an ODRHash object which will be called where pointers would

  /// have been used in the Profile function.

  void ProcessODRHash(llvm::FoldingSetNodeID &ID, ODRHash& Hash) const;

 

class DeclStmt : public Stmt {

  DeclGroupRef DG;

  SourceLocation StartLoc, EndLoc;

 

  DeclStmt(DeclGroupRef dg, SourceLocation startLoc, SourceLocation endLoc)

      : Stmt(DeclStmtClass), DG(dg), StartLoc(startLoc), EndLoc(endLoc) {}

 

  /// Build an empty declaration statement.

  explicit DeclStmt(EmptyShell Empty) : Stmt(DeclStmtClass, Empty) {}

 

  /// isSingleDecl - This method returns true if this DeclStmt refers

  /// to a single Decl.

  bool isSingleDecl() const { return DG.isSingleDecl(); }

 

  const Decl *getSingleDecl() const { return DG.getSingleDecl(); }

  Decl *getSingleDecl() { return DG.getSingleDecl(); }

 

  const DeclGroupRef getDeclGroup() const { return DG; }

  DeclGroupRef getDeclGroup() { return DG; }

  void setDeclGroup(DeclGroupRef DGR) { DG = DGR; }

 

  void setStartLoc(SourceLocation L) { StartLoc = L; }

  SourceLocation getEndLoc() const { return EndLoc; }

  void setEndLoc(SourceLocation L) { EndLoc = L; }

 

  SourceLocation getBeginLoc() const LLVM_READONLY { return StartLoc; }

 

  static bool classof(const Stmt *T) {

    return T->getStmtClass() == DeclStmtClass;

  }

 

  // Iterators over subexpressions.

  child_range children() {

    return child_range(child_iterator(DG.begin(), DG.end()),

                       child_iterator(DG.end(), DG.end()));

  }

 

  const_child_range children() const {

    auto Children = const_cast<DeclStmt *>(this)->children();

    return const_child_range(Children);

  }

 

  using decl_iterator = DeclGroupRef::iterator;

  using const_decl_iterator = DeclGroupRef::const_iterator;

  using decl_range = llvm::iterator_range<decl_iterator>;

  using decl_const_range = llvm::iterator_range<const_decl_iterator>;

 

  decl_range decls() { return decl_range(decl_begin(), decl_end()); }

 

  decl_const_range decls() const {

    return decl_const_range(decl_begin(), decl_end());

  }

 

  decl_iterator decl_begin() { return DG.begin(); }

  decl_iterator decl_end() { return DG.end(); }

  const_decl_iterator decl_begin() const { return DG.begin(); }

  const_decl_iterator decl_end() const { return DG.end(); }

 

  using reverse_decl_iterator = std::reverse_iterator<decl_iterator>;

 

  reverse_decl_iterator decl_rbegin() {

    return reverse_decl_iterator(decl_end());

  }

 

  reverse_decl_iterator decl_rend() {

    return reverse_decl_iterator(decl_begin());

  }

 

class NullStmt : public Stmt {

  NullStmt(SourceLocation L, bool hasLeadingEmptyMacro = false)

      : Stmt(NullStmtClass) {

    NullStmtBits.HasLeadingEmptyMacro = hasLeadingEmptyMacro;

    setSemiLoc(L);

  }

 

  /// Build an empty null statement.

  explicit NullStmt(EmptyShell Empty) : Stmt(NullStmtClass, Empty) {}

 

  SourceLocation getSemiLoc() const { return NullStmtBits.SemiLoc; }

  void setSemiLoc(SourceLocation L) { NullStmtBits.SemiLoc = L; }

 

  bool hasLeadingEmptyMacro() const {

    return NullStmtBits.HasLeadingEmptyMacro;

  }

 

  SourceLocation getBeginLoc() const { return getSemiLoc(); }

  SourceLocation getEndLoc() const { return getSemiLoc(); }

 

  static bool classof(const Stmt *T) {

    return T->getStmtClass() == NullStmtClass;

  }

 

  child_range children() {

    return child_range(child_iterator(), child_iterator());

  }

 

  const_child_range children() const {

    return const_child_range(const_child_iterator(), const_child_iterator());

  }

 

class CompoundStmt final

    : public Stmt,

      private llvm::TrailingObjects<CompoundStmt, Stmt *, FPOptionsOverride> {

  friend class ASTStmtReader;

  friend TrailingObjects;

 

  /// The location of the opening "{".

  SourceLocation LBraceLoc;

 

  /// The location of the closing "}".

  SourceLocation RBraceLoc;

 

  CompoundStmt(ArrayRef<Stmt *> Stmts, FPOptionsOverride FPFeatures,

               SourceLocation LB, SourceLocation RB);

  explicit CompoundStmt(EmptyShell Empty) : Stmt(CompoundStmtClass, Empty) {}

 

  void setStmts(ArrayRef<Stmt *> Stmts);

 

  /// Set FPOptionsOverride in trailing storage. Used only by Serialization.

  void setStoredFPFeatures(FPOptionsOverride F) {

    assert(hasStoredFPFeatures());

    *getTrailingObjects<FPOptionsOverride>() = F;

  }

 

  size_t numTrailingObjects(OverloadToken<Stmt *>) const {

    return CompoundStmtBits.NumStmts;

  }

 

  static CompoundStmt *Create(const ASTContext &C, ArrayRef<Stmt *> Stmts,

                              FPOptionsOverride FPFeatures, SourceLocation LB,

                              SourceLocation RB);

 

  // Build an empty compound statement with a location.

  explicit CompoundStmt(SourceLocation Loc)

      : Stmt(CompoundStmtClass), LBraceLoc(Loc), RBraceLoc(Loc) {

    CompoundStmtBits.NumStmts = 0;

    CompoundStmtBits.HasFPFeatures = 0;

  }

 

  // Build an empty compound statement.

  static CompoundStmt *CreateEmpty(const ASTContext &C, unsigned NumStmts,

                                   bool HasFPFeatures);

 

  bool body_empty() const { return CompoundStmtBits.NumStmts == 0; }

  unsigned size() const { return CompoundStmtBits.NumStmts; }

 

  bool hasStoredFPFeatures() const { return CompoundStmtBits.HasFPFeatures; }

 

  /// Get FPOptionsOverride from trailing storage.

  FPOptionsOverride getStoredFPFeatures() const {

    assert(hasStoredFPFeatures());

    return *getTrailingObjects<FPOptionsOverride>();

  }

 

  using body_iterator = Stmt **;

  using body_range = llvm::iterator_range<body_iterator>;

 

  body_range body() { return body_range(body_begin(), body_end()); }

  body_iterator body_begin() { return getTrailingObjects<Stmt *>(); }

  body_iterator body_end() { return body_begin() + size(); }

  Stmt *body_front() { return !body_empty() ? body_begin()[0] : nullptr; }

 

  Stmt *body_back() {

    return !body_empty() ? body_begin()[size() - 1] : nullptr;

  }

 

  using const_body_iterator = Stmt *const *;

  using body_const_range = llvm::iterator_range<const_body_iterator>;

 

  body_const_range body() const {

    return body_const_range(body_begin(), body_end());

  }

 

  const_body_iterator body_begin() const {

    return getTrailingObjects<Stmt *>();

  }

 

  const_body_iterator body_end() const { return body_begin() + size(); }

 

  const Stmt *body_front() const {

    return !body_empty() ? body_begin()[0] : nullptr;

  }

 

  const Stmt *body_back() const {

    return !body_empty() ? body_begin()[size() - 1] : nullptr;

  }

 

  using reverse_body_iterator = std::reverse_iterator<body_iterator>;

 

  reverse_body_iterator body_rbegin() {

    return reverse_body_iterator(body_end());

  }

 

  reverse_body_iterator body_rend() {

    return reverse_body_iterator(body_begin());

  }

 

  using const_reverse_body_iterator =

      std::reverse_iterator<const_body_iterator>;

 

  const_reverse_body_iterator body_rbegin() const {

    return const_reverse_body_iterator(body_end());

  }

 

  const_reverse_body_iterator body_rend() const {

    return const_reverse_body_iterator(body_begin());

  }

 

  // Get the Stmt that StmtExpr would consider to be the result of this

  // compound statement. This is used by StmtExpr to properly emulate the GCC

  // compound expression extension, which ignores trailing NullStmts when

  // getting the result of the expression.

  // i.e. ({ 5;;; })

  //           ^^ ignored

  // If we don't find something that isn't a NullStmt, just return the last

  // Stmt.

  Stmt *getStmtExprResult() {

    for (auto *B : llvm::reverse(body())) {

      if (!isa<NullStmt>(B))

        return B;

    }

    return body_back();

  }

 

  const Stmt *getStmtExprResult() const {

    return const_cast<CompoundStmt *>(this)->getStmtExprResult();

  }

 

  SourceLocation getBeginLoc() const { return LBraceLoc; }

  SourceLocation getEndLoc() const { return RBraceLoc; }

 

  SourceLocation getLBracLoc() const { return LBraceLoc; }

  SourceLocation getRBracLoc() const { return RBraceLoc; }

 

  static bool classof(const Stmt *T) {

    return T->getStmtClass() == CompoundStmtClass;

  }

 

  // Iterators

  child_range children() { return child_range(body_begin(), body_end()); }

 

  const_child_range children() const {

    return const_child_range(body_begin(), body_end());

  }

 

class SwitchCase : public Stmt {

  /// The location of the ":".

  SourceLocation ColonLoc;

 

  // The location of the "case" or "default" keyword. Stored in SwitchCaseBits.

  // SourceLocation KeywordLoc;

 

  /// A pointer to the following CaseStmt or DefaultStmt class,

  /// used by SwitchStmt.

  SwitchCase *NextSwitchCase = nullptr;

 

  SwitchCase(StmtClass SC, SourceLocation KWLoc, SourceLocation ColonLoc)

      : Stmt(SC), ColonLoc(ColonLoc) {

    setKeywordLoc(KWLoc);

  }

 

  SwitchCase(StmtClass SC, EmptyShell) : Stmt(SC) {}

 

  const SwitchCase *getNextSwitchCase() const { return NextSwitchCase; }

  SwitchCase *getNextSwitchCase() { return NextSwitchCase; }

  void setNextSwitchCase(SwitchCase *SC) { NextSwitchCase = SC; }

 

  SourceLocation getKeywordLoc() const { return SwitchCaseBits.KeywordLoc; }

  void setKeywordLoc(SourceLocation L) { SwitchCaseBits.KeywordLoc = L; }

  SourceLocation getColonLoc() const { return ColonLoc; }

  void setColonLoc(SourceLocation L) { ColonLoc = L; }

 

  inline Stmt *getSubStmt();

  const Stmt *getSubStmt() const {

    return const_cast<SwitchCase *>(this)->getSubStmt();

  }

 

  SourceLocation getBeginLoc() const { return getKeywordLoc(); }

  inline SourceLocation getEndLoc() const LLVM_READONLY;

 

  static bool classof(const Stmt *T) {

    return T->getStmtClass() == CaseStmtClass ||

           T->getStmtClass() == DefaultStmtClass;

  }

 

class CaseStmt final

    : public SwitchCase,

      private llvm::TrailingObjects<CaseStmt, Stmt *, SourceLocation> {

  friend TrailingObjects;

 

  // CaseStmt is followed by several trailing objects, some of which optional.

  // Note that it would be more convenient to put the optional trailing objects

  // at the end but this would impact children().

  // The trailing objects are in order:

  //

  // * A "Stmt *" for the LHS of the case statement. Always present.

  //

  // * A "Stmt *" for the RHS of the case statement. This is a GNU extension

  //   which allow ranges in cases statement of the form LHS ... RHS.

  //   Present if and only if caseStmtIsGNURange() is true.

  //

  // * A "Stmt *" for the substatement of the case statement. Always present.

  //

  // * A SourceLocation for the location of the ... if this is a case statement

  //   with a range. Present if and only if caseStmtIsGNURange() is true.

  enum { LhsOffset = 0, SubStmtOffsetFromRhs = 1 };

  enum { NumMandatoryStmtPtr = 2 };

 

  unsigned numTrailingObjects(OverloadToken<Stmt *>) const {

    return NumMandatoryStmtPtr + caseStmtIsGNURange();

  }

 

  unsigned numTrailingObjects(OverloadToken<SourceLocation>) const {

    return caseStmtIsGNURange();

  }

 

  unsigned lhsOffset() const { return LhsOffset; }

  unsigned rhsOffset() const { return LhsOffset + caseStmtIsGNURange(); }

  unsigned subStmtOffset() const { return rhsOffset() + SubStmtOffsetFromRhs; }

 

  /// Build a case statement assuming that the storage for the

  /// trailing objects has been properly allocated.

  CaseStmt(Expr *lhs, Expr *rhs, SourceLocation caseLoc,

           SourceLocation ellipsisLoc, SourceLocation colonLoc)

      : SwitchCase(CaseStmtClass, caseLoc, colonLoc) {

    // Handle GNU case statements of the form LHS ... RHS.

    bool IsGNURange = rhs != nullptr;

    SwitchCaseBits.CaseStmtIsGNURange = IsGNURange;

    setLHS(lhs);

    setSubStmt(nullptr);

    if (IsGNURange) {

      setRHS(rhs);

      setEllipsisLoc(ellipsisLoc);

    }

  }

 

  /// Build an empty switch case statement.

  explicit CaseStmt(EmptyShell Empty, bool CaseStmtIsGNURange)

      : SwitchCase(CaseStmtClass, Empty) {

    SwitchCaseBits.CaseStmtIsGNURange = CaseStmtIsGNURange;

  }

 

  /// Build a case statement.

  static CaseStmt *Create(const ASTContext &Ctx, Expr *lhs, Expr *rhs,

                          SourceLocation caseLoc, SourceLocation ellipsisLoc,

                          SourceLocation colonLoc);

 

  /// Build an empty case statement.

  static CaseStmt *CreateEmpty(const ASTContext &Ctx, bool CaseStmtIsGNURange);

 

  /// True if this case statement is of the form case LHS ... RHS, which

  /// is a GNU extension. In this case the RHS can be obtained with getRHS()

  /// and the location of the ellipsis can be obtained with getEllipsisLoc().

  bool caseStmtIsGNURange() const { return SwitchCaseBits.CaseStmtIsGNURange; }

 

  SourceLocation getCaseLoc() const { return getKeywordLoc(); }

  void setCaseLoc(SourceLocation L) { setKeywordLoc(L); }

 

  /// Get the location of the ... in a case statement of the form LHS ... RHS.

  SourceLocation getEllipsisLoc() const {

    return caseStmtIsGNURange() ? *getTrailingObjects<SourceLocation>()

                                : SourceLocation();

  }

 

  /// Set the location of the ... in a case statement of the form LHS ... RHS.

  /// Assert that this case statement is of this form.

  void setEllipsisLoc(SourceLocation L) {

    assert(

        caseStmtIsGNURange() &&

        "setEllipsisLoc but this is not a case stmt of the form LHS ... RHS!");

    *getTrailingObjects<SourceLocation>() = L;

  }

 

  Expr *getLHS() {

    return reinterpret_cast<Expr *>(getTrailingObjects<Stmt *>()[lhsOffset()]);

  }

 

  const Expr *getLHS() const {

    return reinterpret_cast<Expr *>(getTrailingObjects<Stmt *>()[lhsOffset()]);

  }

 

  void setLHS(Expr *Val) {

    getTrailingObjects<Stmt *>()[lhsOffset()] = reinterpret_cast<Stmt *>(Val);

  }

 

  Expr *getRHS() {

    return caseStmtIsGNURange() ? reinterpret_cast<Expr *>(

                                      getTrailingObjects<Stmt *>()[rhsOffset()])

                                : nullptr;

  }

 

  const Expr *getRHS() const {

    return caseStmtIsGNURange() ? reinterpret_cast<Expr *>(

                                      getTrailingObjects<Stmt *>()[rhsOffset()])

                                : nullptr;

  }

 

  void setRHS(Expr *Val) {

    assert(caseStmtIsGNURange() &&

           "setRHS but this is not a case stmt of the form LHS ... RHS!");

    getTrailingObjects<Stmt *>()[rhsOffset()] = reinterpret_cast<Stmt *>(Val);

  }

 

  Stmt *getSubStmt() { return getTrailingObjects<Stmt *>()[subStmtOffset()]; }

  const Stmt *getSubStmt() const {

    return getTrailingObjects<Stmt *>()[subStmtOffset()];

  }

 

  void setSubStmt(Stmt *S) {

    getTrailingObjects<Stmt *>()[subStmtOffset()] = S;

  }

 

  SourceLocation getBeginLoc() const { return getKeywordLoc(); }

  SourceLocation getEndLoc() const LLVM_READONLY {

    // Handle deeply nested case statements with iteration instead of recursion.

    const CaseStmt *CS = this;

    while (const auto *CS2 = dyn_cast<CaseStmt>(CS->getSubStmt()))

      CS = CS2;

 

    return CS->getSubStmt()->getEndLoc();

  }

 

  static bool classof(const Stmt *T) {

    return T->getStmtClass() == CaseStmtClass;

  }

 

  // Iterators

  child_range children() {

    return child_range(getTrailingObjects<Stmt *>(),

                       getTrailingObjects<Stmt *>() +

                           numTrailingObjects(OverloadToken<Stmt *>()));

  }

 

  const_child_range children() const {

    return const_child_range(getTrailingObjects<Stmt *>(),

                             getTrailingObjects<Stmt *>() +

                                 numTrailingObjects(OverloadToken<Stmt *>()));

  }

 

class DefaultStmt : public SwitchCase {

  Stmt *SubStmt;

 

  DefaultStmt(SourceLocation DL, SourceLocation CL, Stmt *substmt)

      : SwitchCase(DefaultStmtClass, DL, CL), SubStmt(substmt) {}

 

  /// Build an empty default statement.

  explicit DefaultStmt(EmptyShell Empty)

      : SwitchCase(DefaultStmtClass, Empty) {}

 

  Stmt *getSubStmt() { return SubStmt; }

  const Stmt *getSubStmt() const { return SubStmt; }

  void setSubStmt(Stmt *S) { SubStmt = S; }

 

  SourceLocation getDefaultLoc() const { return getKeywordLoc(); }

  void setDefaultLoc(SourceLocation L) { setKeywordLoc(L); }

 

  SourceLocation getBeginLoc() const { return getKeywordLoc(); }

  SourceLocation getEndLoc() const LLVM_READONLY {

    return SubStmt->getEndLoc();

  }

 

  static bool classof(const Stmt *T) {

    return T->getStmtClass() == DefaultStmtClass;

  }

 

  // Iterators

  child_range children() { return child_range(&SubStmt, &SubStmt + 1); }

 

  const_child_range children() const {

    return const_child_range(&SubStmt, &SubStmt + 1);

  }