Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===--- DeclSpec.h - Parsed declaration specifiers -------------*- C++ -*-===//
  2. //
  3. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4. // See https://llvm.org/LICENSE.txt for license information.
  5. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6. //
  7. //===----------------------------------------------------------------------===//
  8. ///
  9. /// \file
  10. /// This file defines the classes used to store parsed information about
  11. /// declaration-specifiers and declarators.
  12. ///
  13. /// \verbatim
  14. ///   static const int volatile x, *y, *(*(*z)[10])(const void *x);
  15. ///   ------------------------- -  --  ---------------------------
  16. ///     declaration-specifiers  \  |   /
  17. ///                            declarators
  18. /// \endverbatim
  19. ///
  20. //===----------------------------------------------------------------------===//
  21.  
  22. #ifndef LLVM_CLANG_SEMA_DECLSPEC_H
  23. #define LLVM_CLANG_SEMA_DECLSPEC_H
  24.  
  25. #include "clang/AST/DeclCXX.h"
  26. #include "clang/AST/DeclObjCCommon.h"
  27. #include "clang/AST/NestedNameSpecifier.h"
  28. #include "clang/Basic/ExceptionSpecificationType.h"
  29. #include "clang/Basic/Lambda.h"
  30. #include "clang/Basic/OperatorKinds.h"
  31. #include "clang/Basic/Specifiers.h"
  32. #include "clang/Lex/Token.h"
  33. #include "clang/Sema/Ownership.h"
  34. #include "clang/Sema/ParsedAttr.h"
  35. #include "llvm/ADT/STLExtras.h"
  36. #include "llvm/ADT/SmallVector.h"
  37. #include "llvm/Support/Compiler.h"
  38. #include "llvm/Support/ErrorHandling.h"
  39.  
  40. namespace clang {
  41.   class ASTContext;
  42.   class CXXRecordDecl;
  43.   class TypeLoc;
  44.   class LangOptions;
  45.   class IdentifierInfo;
  46.   class NamespaceAliasDecl;
  47.   class NamespaceDecl;
  48.   class ObjCDeclSpec;
  49.   class Sema;
  50.   class Declarator;
  51.   struct TemplateIdAnnotation;
  52.  
  53. /// Represents a C++ nested-name-specifier or a global scope specifier.
  54. ///
  55. /// These can be in 3 states:
  56. ///   1) Not present, identified by isEmpty()
  57. ///   2) Present, identified by isNotEmpty()
  58. ///      2.a) Valid, identified by isValid()
  59. ///      2.b) Invalid, identified by isInvalid().
  60. ///
  61. /// isSet() is deprecated because it mostly corresponded to "valid" but was
  62. /// often used as if it meant "present".
  63. ///
  64. /// The actual scope is described by getScopeRep().
  65. class CXXScopeSpec {
  66.   SourceRange Range;
  67.   NestedNameSpecifierLocBuilder Builder;
  68.  
  69. public:
  70.   SourceRange getRange() const { return Range; }
  71.   void setRange(SourceRange R) { Range = R; }
  72.   void setBeginLoc(SourceLocation Loc) { Range.setBegin(Loc); }
  73.   void setEndLoc(SourceLocation Loc) { Range.setEnd(Loc); }
  74.   SourceLocation getBeginLoc() const { return Range.getBegin(); }
  75.   SourceLocation getEndLoc() const { return Range.getEnd(); }
  76.  
  77.   /// Retrieve the representation of the nested-name-specifier.
  78.   NestedNameSpecifier *getScopeRep() const {
  79.     return Builder.getRepresentation();
  80.   }
  81.  
  82.   /// Extend the current nested-name-specifier by another
  83.   /// nested-name-specifier component of the form 'type::'.
  84.   ///
  85.   /// \param Context The AST context in which this nested-name-specifier
  86.   /// resides.
  87.   ///
  88.   /// \param TemplateKWLoc The location of the 'template' keyword, if present.
  89.   ///
  90.   /// \param TL The TypeLoc that describes the type preceding the '::'.
  91.   ///
  92.   /// \param ColonColonLoc The location of the trailing '::'.
  93.   void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL,
  94.               SourceLocation ColonColonLoc);
  95.  
  96.   /// Extend the current nested-name-specifier by another
  97.   /// nested-name-specifier component of the form 'identifier::'.
  98.   ///
  99.   /// \param Context The AST context in which this nested-name-specifier
  100.   /// resides.
  101.   ///
  102.   /// \param Identifier The identifier.
  103.   ///
  104.   /// \param IdentifierLoc The location of the identifier.
  105.   ///
  106.   /// \param ColonColonLoc The location of the trailing '::'.
  107.   void Extend(ASTContext &Context, IdentifierInfo *Identifier,
  108.               SourceLocation IdentifierLoc, SourceLocation ColonColonLoc);
  109.  
  110.   /// Extend the current nested-name-specifier by another
  111.   /// nested-name-specifier component of the form 'namespace::'.
  112.   ///
  113.   /// \param Context The AST context in which this nested-name-specifier
  114.   /// resides.
  115.   ///
  116.   /// \param Namespace The namespace.
  117.   ///
  118.   /// \param NamespaceLoc The location of the namespace name.
  119.   ///
  120.   /// \param ColonColonLoc The location of the trailing '::'.
  121.   void Extend(ASTContext &Context, NamespaceDecl *Namespace,
  122.               SourceLocation NamespaceLoc, SourceLocation ColonColonLoc);
  123.  
  124.   /// Extend the current nested-name-specifier by another
  125.   /// nested-name-specifier component of the form 'namespace-alias::'.
  126.   ///
  127.   /// \param Context The AST context in which this nested-name-specifier
  128.   /// resides.
  129.   ///
  130.   /// \param Alias The namespace alias.
  131.   ///
  132.   /// \param AliasLoc The location of the namespace alias
  133.   /// name.
  134.   ///
  135.   /// \param ColonColonLoc The location of the trailing '::'.
  136.   void Extend(ASTContext &Context, NamespaceAliasDecl *Alias,
  137.               SourceLocation AliasLoc, SourceLocation ColonColonLoc);
  138.  
  139.   /// Turn this (empty) nested-name-specifier into the global
  140.   /// nested-name-specifier '::'.
  141.   void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc);
  142.  
  143.   /// Turns this (empty) nested-name-specifier into '__super'
  144.   /// nested-name-specifier.
  145.   ///
  146.   /// \param Context The AST context in which this nested-name-specifier
  147.   /// resides.
  148.   ///
  149.   /// \param RD The declaration of the class in which nested-name-specifier
  150.   /// appeared.
  151.   ///
  152.   /// \param SuperLoc The location of the '__super' keyword.
  153.   /// name.
  154.   ///
  155.   /// \param ColonColonLoc The location of the trailing '::'.
  156.   void MakeSuper(ASTContext &Context, CXXRecordDecl *RD,
  157.                  SourceLocation SuperLoc, SourceLocation ColonColonLoc);
  158.  
  159.   /// Make a new nested-name-specifier from incomplete source-location
  160.   /// information.
  161.   ///
  162.   /// FIXME: This routine should be used very, very rarely, in cases where we
  163.   /// need to synthesize a nested-name-specifier. Most code should instead use
  164.   /// \c Adopt() with a proper \c NestedNameSpecifierLoc.
  165.   void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier,
  166.                    SourceRange R);
  167.  
  168.   /// Adopt an existing nested-name-specifier (with source-range
  169.   /// information).
  170.   void Adopt(NestedNameSpecifierLoc Other);
  171.  
  172.   /// Retrieve a nested-name-specifier with location information, copied
  173.   /// into the given AST context.
  174.   ///
  175.   /// \param Context The context into which this nested-name-specifier will be
  176.   /// copied.
  177.   NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const;
  178.  
  179.   /// Retrieve the location of the name in the last qualifier
  180.   /// in this nested name specifier.
  181.   ///
  182.   /// For example, the location of \c bar
  183.   /// in
  184.   /// \verbatim
  185.   ///   \::foo::bar<0>::
  186.   ///           ^~~
  187.   /// \endverbatim
  188.   SourceLocation getLastQualifierNameLoc() const;
  189.  
  190.   /// No scope specifier.
  191.   bool isEmpty() const { return Range.isInvalid() && getScopeRep() == nullptr; }
  192.   /// A scope specifier is present, but may be valid or invalid.
  193.   bool isNotEmpty() const { return !isEmpty(); }
  194.  
  195.   /// An error occurred during parsing of the scope specifier.
  196.   bool isInvalid() const { return Range.isValid() && getScopeRep() == nullptr; }
  197.   /// A scope specifier is present, and it refers to a real scope.
  198.   bool isValid() const { return getScopeRep() != nullptr; }
  199.  
  200.   /// Indicate that this nested-name-specifier is invalid.
  201.   void SetInvalid(SourceRange R) {
  202.     assert(R.isValid() && "Must have a valid source range");
  203.     if (Range.getBegin().isInvalid())
  204.       Range.setBegin(R.getBegin());
  205.     Range.setEnd(R.getEnd());
  206.     Builder.Clear();
  207.   }
  208.  
  209.   /// Deprecated.  Some call sites intend isNotEmpty() while others intend
  210.   /// isValid().
  211.   bool isSet() const { return getScopeRep() != nullptr; }
  212.  
  213.   void clear() {
  214.     Range = SourceRange();
  215.     Builder.Clear();
  216.   }
  217.  
  218.   /// Retrieve the data associated with the source-location information.
  219.   char *location_data() const { return Builder.getBuffer().first; }
  220.  
  221.   /// Retrieve the size of the data associated with source-location
  222.   /// information.
  223.   unsigned location_size() const { return Builder.getBuffer().second; }
  224. };
  225.  
  226. /// Captures information about "declaration specifiers".
  227. ///
  228. /// "Declaration specifiers" encompasses storage-class-specifiers,
  229. /// type-specifiers, type-qualifiers, and function-specifiers.
  230. class DeclSpec {
  231. public:
  232.   /// storage-class-specifier
  233.   /// \note The order of these enumerators is important for diagnostics.
  234.   enum SCS {
  235.     SCS_unspecified = 0,
  236.     SCS_typedef,
  237.     SCS_extern,
  238.     SCS_static,
  239.     SCS_auto,
  240.     SCS_register,
  241.     SCS_private_extern,
  242.     SCS_mutable
  243.   };
  244.  
  245.   // Import thread storage class specifier enumeration and constants.
  246.   // These can be combined with SCS_extern and SCS_static.
  247.   typedef ThreadStorageClassSpecifier TSCS;
  248.   static const TSCS TSCS_unspecified = clang::TSCS_unspecified;
  249.   static const TSCS TSCS___thread = clang::TSCS___thread;
  250.   static const TSCS TSCS_thread_local = clang::TSCS_thread_local;
  251.   static const TSCS TSCS__Thread_local = clang::TSCS__Thread_local;
  252.  
  253.   enum TSC {
  254.     TSC_unspecified,
  255.     TSC_imaginary,
  256.     TSC_complex
  257.   };
  258.  
  259.   // Import type specifier type enumeration and constants.
  260.   typedef TypeSpecifierType TST;
  261.   static const TST TST_unspecified = clang::TST_unspecified;
  262.   static const TST TST_void = clang::TST_void;
  263.   static const TST TST_char = clang::TST_char;
  264.   static const TST TST_wchar = clang::TST_wchar;
  265.   static const TST TST_char8 = clang::TST_char8;
  266.   static const TST TST_char16 = clang::TST_char16;
  267.   static const TST TST_char32 = clang::TST_char32;
  268.   static const TST TST_int = clang::TST_int;
  269.   static const TST TST_int128 = clang::TST_int128;
  270.   static const TST TST_bitint = clang::TST_bitint;
  271.   static const TST TST_half = clang::TST_half;
  272.   static const TST TST_BFloat16 = clang::TST_BFloat16;
  273.   static const TST TST_float = clang::TST_float;
  274.   static const TST TST_double = clang::TST_double;
  275.   static const TST TST_float16 = clang::TST_Float16;
  276.   static const TST TST_accum = clang::TST_Accum;
  277.   static const TST TST_fract = clang::TST_Fract;
  278.   static const TST TST_float128 = clang::TST_float128;
  279.   static const TST TST_ibm128 = clang::TST_ibm128;
  280.   static const TST TST_bool = clang::TST_bool;
  281.   static const TST TST_decimal32 = clang::TST_decimal32;
  282.   static const TST TST_decimal64 = clang::TST_decimal64;
  283.   static const TST TST_decimal128 = clang::TST_decimal128;
  284.   static const TST TST_enum = clang::TST_enum;
  285.   static const TST TST_union = clang::TST_union;
  286.   static const TST TST_struct = clang::TST_struct;
  287.   static const TST TST_interface = clang::TST_interface;
  288.   static const TST TST_class = clang::TST_class;
  289.   static const TST TST_typename = clang::TST_typename;
  290.   static const TST TST_typeofType = clang::TST_typeofType;
  291.   static const TST TST_typeofExpr = clang::TST_typeofExpr;
  292.   static const TST TST_typeof_unqualType = clang::TST_typeof_unqualType;
  293.   static const TST TST_typeof_unqualExpr = clang::TST_typeof_unqualExpr;
  294.   static const TST TST_decltype = clang::TST_decltype;
  295.   static const TST TST_decltype_auto = clang::TST_decltype_auto;
  296. #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait)                                     \
  297.   static const TST TST_##Trait = clang::TST_##Trait;
  298. #include "clang/Basic/TransformTypeTraits.def"
  299.   static const TST TST_auto = clang::TST_auto;
  300.   static const TST TST_auto_type = clang::TST_auto_type;
  301.   static const TST TST_unknown_anytype = clang::TST_unknown_anytype;
  302.   static const TST TST_atomic = clang::TST_atomic;
  303. #define GENERIC_IMAGE_TYPE(ImgType, Id) \
  304.   static const TST TST_##ImgType##_t = clang::TST_##ImgType##_t;
  305. #include "clang/Basic/OpenCLImageTypes.def"
  306.   static const TST TST_error = clang::TST_error;
  307.  
  308.   // type-qualifiers
  309.   enum TQ {   // NOTE: These flags must be kept in sync with Qualifiers::TQ.
  310.     TQ_unspecified = 0,
  311.     TQ_const       = 1,
  312.     TQ_restrict    = 2,
  313.     TQ_volatile    = 4,
  314.     TQ_unaligned   = 8,
  315.     // This has no corresponding Qualifiers::TQ value, because it's not treated
  316.     // as a qualifier in our type system.
  317.     TQ_atomic      = 16
  318.   };
  319.  
  320.   /// ParsedSpecifiers - Flags to query which specifiers were applied.  This is
  321.   /// returned by getParsedSpecifiers.
  322.   enum ParsedSpecifiers {
  323.     PQ_None                  = 0,
  324.     PQ_StorageClassSpecifier = 1,
  325.     PQ_TypeSpecifier         = 2,
  326.     PQ_TypeQualifier         = 4,
  327.     PQ_FunctionSpecifier     = 8
  328.     // FIXME: Attributes should be included here.
  329.   };
  330.  
  331.   enum FriendSpecified : bool {
  332.     No,
  333.     Yes,
  334.   };
  335.  
  336. private:
  337.   // storage-class-specifier
  338.   /*SCS*/unsigned StorageClassSpec : 3;
  339.   /*TSCS*/unsigned ThreadStorageClassSpec : 2;
  340.   unsigned SCS_extern_in_linkage_spec : 1;
  341.  
  342.   // type-specifier
  343.   /*TypeSpecifierWidth*/ unsigned TypeSpecWidth : 2;
  344.   /*TSC*/unsigned TypeSpecComplex : 2;
  345.   /*TSS*/unsigned TypeSpecSign : 2;
  346.   /*TST*/unsigned TypeSpecType : 7;
  347.   unsigned TypeAltiVecVector : 1;
  348.   unsigned TypeAltiVecPixel : 1;
  349.   unsigned TypeAltiVecBool : 1;
  350.   unsigned TypeSpecOwned : 1;
  351.   unsigned TypeSpecPipe : 1;
  352.   unsigned TypeSpecSat : 1;
  353.   unsigned ConstrainedAuto : 1;
  354.  
  355.   // type-qualifiers
  356.   unsigned TypeQualifiers : 5;  // Bitwise OR of TQ.
  357.  
  358.   // function-specifier
  359.   unsigned FS_inline_specified : 1;
  360.   unsigned FS_forceinline_specified: 1;
  361.   unsigned FS_virtual_specified : 1;
  362.   unsigned FS_noreturn_specified : 1;
  363.  
  364.   // friend-specifier
  365.   unsigned Friend_specified : 1;
  366.  
  367.   // constexpr-specifier
  368.   unsigned ConstexprSpecifier : 2;
  369.  
  370.   union {
  371.     UnionParsedType TypeRep;
  372.     Decl *DeclRep;
  373.     Expr *ExprRep;
  374.     TemplateIdAnnotation *TemplateIdRep;
  375.   };
  376.  
  377.   /// ExplicitSpecifier - Store information about explicit spicifer.
  378.   ExplicitSpecifier FS_explicit_specifier;
  379.  
  380.   // attributes.
  381.   ParsedAttributes Attrs;
  382.  
  383.   // Scope specifier for the type spec, if applicable.
  384.   CXXScopeSpec TypeScope;
  385.  
  386.   // SourceLocation info.  These are null if the item wasn't specified or if
  387.   // the setting was synthesized.
  388.   SourceRange Range;
  389.  
  390.   SourceLocation StorageClassSpecLoc, ThreadStorageClassSpecLoc;
  391.   SourceRange TSWRange;
  392.   SourceLocation TSCLoc, TSSLoc, TSTLoc, AltiVecLoc, TSSatLoc;
  393.   /// TSTNameLoc - If TypeSpecType is any of class, enum, struct, union,
  394.   /// typename, then this is the location of the named type (if present);
  395.   /// otherwise, it is the same as TSTLoc. Hence, the pair TSTLoc and
  396.   /// TSTNameLoc provides source range info for tag types.
  397.   SourceLocation TSTNameLoc;
  398.   SourceRange TypeofParensRange;
  399.   SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc,
  400.       TQ_unalignedLoc;
  401.   SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc;
  402.   SourceLocation FS_explicitCloseParenLoc;
  403.   SourceLocation FS_forceinlineLoc;
  404.   SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc;
  405.   SourceLocation TQ_pipeLoc;
  406.  
  407.   WrittenBuiltinSpecs writtenBS;
  408.   void SaveWrittenBuiltinSpecs();
  409.  
  410.   ObjCDeclSpec *ObjCQualifiers;
  411.  
  412.   static bool isTypeRep(TST T) {
  413.     return T == TST_atomic || T == TST_typename || T == TST_typeofType ||
  414.            T == TST_typeof_unqualType || isTransformTypeTrait(T);
  415.   }
  416.   static bool isExprRep(TST T) {
  417.     return T == TST_typeofExpr || T == TST_typeof_unqualExpr ||
  418.            T == TST_decltype || T == TST_bitint;
  419.   }
  420.   static bool isTemplateIdRep(TST T) {
  421.     return (T == TST_auto || T == TST_decltype_auto);
  422.   }
  423.  
  424.   DeclSpec(const DeclSpec &) = delete;
  425.   void operator=(const DeclSpec &) = delete;
  426. public:
  427.   static bool isDeclRep(TST T) {
  428.     return (T == TST_enum || T == TST_struct ||
  429.             T == TST_interface || T == TST_union ||
  430.             T == TST_class);
  431.   }
  432.   static bool isTransformTypeTrait(TST T) {
  433.     constexpr std::array<TST, 16> Traits = {
  434. #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) TST_##Trait,
  435. #include "clang/Basic/TransformTypeTraits.def"
  436.     };
  437.  
  438.     return T >= Traits.front() && T <= Traits.back();
  439.   }
  440.  
  441.   DeclSpec(AttributeFactory &attrFactory)
  442.       : StorageClassSpec(SCS_unspecified),
  443.         ThreadStorageClassSpec(TSCS_unspecified),
  444.         SCS_extern_in_linkage_spec(false),
  445.         TypeSpecWidth(static_cast<unsigned>(TypeSpecifierWidth::Unspecified)),
  446.         TypeSpecComplex(TSC_unspecified),
  447.         TypeSpecSign(static_cast<unsigned>(TypeSpecifierSign::Unspecified)),
  448.         TypeSpecType(TST_unspecified), TypeAltiVecVector(false),
  449.         TypeAltiVecPixel(false), TypeAltiVecBool(false), TypeSpecOwned(false),
  450.         TypeSpecPipe(false), TypeSpecSat(false), ConstrainedAuto(false),
  451.         TypeQualifiers(TQ_unspecified), FS_inline_specified(false),
  452.         FS_forceinline_specified(false), FS_virtual_specified(false),
  453.         FS_noreturn_specified(false), Friend_specified(false),
  454.         ConstexprSpecifier(
  455.             static_cast<unsigned>(ConstexprSpecKind::Unspecified)),
  456.         Attrs(attrFactory), writtenBS(), ObjCQualifiers(nullptr) {}
  457.  
  458.   // storage-class-specifier
  459.   SCS getStorageClassSpec() const { return (SCS)StorageClassSpec; }
  460.   TSCS getThreadStorageClassSpec() const {
  461.     return (TSCS)ThreadStorageClassSpec;
  462.   }
  463.   bool isExternInLinkageSpec() const { return SCS_extern_in_linkage_spec; }
  464.   void setExternInLinkageSpec(bool Value) {
  465.     SCS_extern_in_linkage_spec = Value;
  466.   }
  467.  
  468.   SourceLocation getStorageClassSpecLoc() const { return StorageClassSpecLoc; }
  469.   SourceLocation getThreadStorageClassSpecLoc() const {
  470.     return ThreadStorageClassSpecLoc;
  471.   }
  472.  
  473.   void ClearStorageClassSpecs() {
  474.     StorageClassSpec           = DeclSpec::SCS_unspecified;
  475.     ThreadStorageClassSpec     = DeclSpec::TSCS_unspecified;
  476.     SCS_extern_in_linkage_spec = false;
  477.     StorageClassSpecLoc        = SourceLocation();
  478.     ThreadStorageClassSpecLoc  = SourceLocation();
  479.   }
  480.  
  481.   void ClearTypeSpecType() {
  482.     TypeSpecType = DeclSpec::TST_unspecified;
  483.     TypeSpecOwned = false;
  484.     TSTLoc = SourceLocation();
  485.   }
  486.  
  487.   // type-specifier
  488.   TypeSpecifierWidth getTypeSpecWidth() const {
  489.     return static_cast<TypeSpecifierWidth>(TypeSpecWidth);
  490.   }
  491.   TSC getTypeSpecComplex() const { return (TSC)TypeSpecComplex; }
  492.   TypeSpecifierSign getTypeSpecSign() const {
  493.     return static_cast<TypeSpecifierSign>(TypeSpecSign);
  494.   }
  495.   TST getTypeSpecType() const { return (TST)TypeSpecType; }
  496.   bool isTypeAltiVecVector() const { return TypeAltiVecVector; }
  497.   bool isTypeAltiVecPixel() const { return TypeAltiVecPixel; }
  498.   bool isTypeAltiVecBool() const { return TypeAltiVecBool; }
  499.   bool isTypeSpecOwned() const { return TypeSpecOwned; }
  500.   bool isTypeRep() const { return isTypeRep((TST) TypeSpecType); }
  501.   bool isTypeSpecPipe() const { return TypeSpecPipe; }
  502.   bool isTypeSpecSat() const { return TypeSpecSat; }
  503.   bool isConstrainedAuto() const { return ConstrainedAuto; }
  504.  
  505.   ParsedType getRepAsType() const {
  506.     assert(isTypeRep((TST) TypeSpecType) && "DeclSpec does not store a type");
  507.     return TypeRep;
  508.   }
  509.   Decl *getRepAsDecl() const {
  510.     assert(isDeclRep((TST) TypeSpecType) && "DeclSpec does not store a decl");
  511.     return DeclRep;
  512.   }
  513.   Expr *getRepAsExpr() const {
  514.     assert(isExprRep((TST) TypeSpecType) && "DeclSpec does not store an expr");
  515.     return ExprRep;
  516.   }
  517.   TemplateIdAnnotation *getRepAsTemplateId() const {
  518.     assert(isTemplateIdRep((TST) TypeSpecType) &&
  519.            "DeclSpec does not store a template id");
  520.     return TemplateIdRep;
  521.   }
  522.   CXXScopeSpec &getTypeSpecScope() { return TypeScope; }
  523.   const CXXScopeSpec &getTypeSpecScope() const { return TypeScope; }
  524.  
  525.   SourceRange getSourceRange() const LLVM_READONLY { return Range; }
  526.   SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }
  527.   SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }
  528.  
  529.   SourceLocation getTypeSpecWidthLoc() const { return TSWRange.getBegin(); }
  530.   SourceRange getTypeSpecWidthRange() const { return TSWRange; }
  531.   SourceLocation getTypeSpecComplexLoc() const { return TSCLoc; }
  532.   SourceLocation getTypeSpecSignLoc() const { return TSSLoc; }
  533.   SourceLocation getTypeSpecTypeLoc() const { return TSTLoc; }
  534.   SourceLocation getAltiVecLoc() const { return AltiVecLoc; }
  535.   SourceLocation getTypeSpecSatLoc() const { return TSSatLoc; }
  536.  
  537.   SourceLocation getTypeSpecTypeNameLoc() const {
  538.     assert(isDeclRep((TST)TypeSpecType) || isTypeRep((TST)TypeSpecType) ||
  539.            isExprRep((TST)TypeSpecType));
  540.     return TSTNameLoc;
  541.   }
  542.  
  543.   SourceRange getTypeofParensRange() const { return TypeofParensRange; }
  544.   void setTypeArgumentRange(SourceRange range) { TypeofParensRange = range; }
  545.  
  546.   bool hasAutoTypeSpec() const {
  547.     return (TypeSpecType == TST_auto || TypeSpecType == TST_auto_type ||
  548.             TypeSpecType == TST_decltype_auto);
  549.   }
  550.  
  551.   bool hasTagDefinition() const;
  552.  
  553.   /// Turn a type-specifier-type into a string like "_Bool" or "union".
  554.   static const char *getSpecifierName(DeclSpec::TST T,
  555.                                       const PrintingPolicy &Policy);
  556.   static const char *getSpecifierName(DeclSpec::TQ Q);
  557.   static const char *getSpecifierName(TypeSpecifierSign S);
  558.   static const char *getSpecifierName(DeclSpec::TSC C);
  559.   static const char *getSpecifierName(TypeSpecifierWidth W);
  560.   static const char *getSpecifierName(DeclSpec::SCS S);
  561.   static const char *getSpecifierName(DeclSpec::TSCS S);
  562.   static const char *getSpecifierName(ConstexprSpecKind C);
  563.  
  564.   // type-qualifiers
  565.  
  566.   /// getTypeQualifiers - Return a set of TQs.
  567.   unsigned getTypeQualifiers() const { return TypeQualifiers; }
  568.   SourceLocation getConstSpecLoc() const { return TQ_constLoc; }
  569.   SourceLocation getRestrictSpecLoc() const { return TQ_restrictLoc; }
  570.   SourceLocation getVolatileSpecLoc() const { return TQ_volatileLoc; }
  571.   SourceLocation getAtomicSpecLoc() const { return TQ_atomicLoc; }
  572.   SourceLocation getUnalignedSpecLoc() const { return TQ_unalignedLoc; }
  573.   SourceLocation getPipeLoc() const { return TQ_pipeLoc; }
  574.  
  575.   /// Clear out all of the type qualifiers.
  576.   void ClearTypeQualifiers() {
  577.     TypeQualifiers = 0;
  578.     TQ_constLoc = SourceLocation();
  579.     TQ_restrictLoc = SourceLocation();
  580.     TQ_volatileLoc = SourceLocation();
  581.     TQ_atomicLoc = SourceLocation();
  582.     TQ_unalignedLoc = SourceLocation();
  583.     TQ_pipeLoc = SourceLocation();
  584.   }
  585.  
  586.   // function-specifier
  587.   bool isInlineSpecified() const {
  588.     return FS_inline_specified | FS_forceinline_specified;
  589.   }
  590.   SourceLocation getInlineSpecLoc() const {
  591.     return FS_inline_specified ? FS_inlineLoc : FS_forceinlineLoc;
  592.   }
  593.  
  594.   ExplicitSpecifier getExplicitSpecifier() const {
  595.     return FS_explicit_specifier;
  596.   }
  597.  
  598.   bool isVirtualSpecified() const { return FS_virtual_specified; }
  599.   SourceLocation getVirtualSpecLoc() const { return FS_virtualLoc; }
  600.  
  601.   bool hasExplicitSpecifier() const {
  602.     return FS_explicit_specifier.isSpecified();
  603.   }
  604.   SourceLocation getExplicitSpecLoc() const { return FS_explicitLoc; }
  605.   SourceRange getExplicitSpecRange() const {
  606.     return FS_explicit_specifier.getExpr()
  607.                ? SourceRange(FS_explicitLoc, FS_explicitCloseParenLoc)
  608.                : SourceRange(FS_explicitLoc);
  609.   }
  610.  
  611.   bool isNoreturnSpecified() const { return FS_noreturn_specified; }
  612.   SourceLocation getNoreturnSpecLoc() const { return FS_noreturnLoc; }
  613.  
  614.   void ClearFunctionSpecs() {
  615.     FS_inline_specified = false;
  616.     FS_inlineLoc = SourceLocation();
  617.     FS_forceinline_specified = false;
  618.     FS_forceinlineLoc = SourceLocation();
  619.     FS_virtual_specified = false;
  620.     FS_virtualLoc = SourceLocation();
  621.     FS_explicit_specifier = ExplicitSpecifier();
  622.     FS_explicitLoc = SourceLocation();
  623.     FS_explicitCloseParenLoc = SourceLocation();
  624.     FS_noreturn_specified = false;
  625.     FS_noreturnLoc = SourceLocation();
  626.   }
  627.  
  628.   /// This method calls the passed in handler on each CVRU qual being
  629.   /// set.
  630.   /// Handle - a handler to be invoked.
  631.   void forEachCVRUQualifier(
  632.       llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle);
  633.  
  634.   /// This method calls the passed in handler on each qual being
  635.   /// set.
  636.   /// Handle - a handler to be invoked.
  637.   void forEachQualifier(
  638.       llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle);
  639.  
  640.   /// Return true if any type-specifier has been found.
  641.   bool hasTypeSpecifier() const {
  642.     return getTypeSpecType() != DeclSpec::TST_unspecified ||
  643.            getTypeSpecWidth() != TypeSpecifierWidth::Unspecified ||
  644.            getTypeSpecComplex() != DeclSpec::TSC_unspecified ||
  645.            getTypeSpecSign() != TypeSpecifierSign::Unspecified;
  646.   }
  647.  
  648.   /// Return a bitmask of which flavors of specifiers this
  649.   /// DeclSpec includes.
  650.   unsigned getParsedSpecifiers() const;
  651.  
  652.   /// isEmpty - Return true if this declaration specifier is completely empty:
  653.   /// no tokens were parsed in the production of it.
  654.   bool isEmpty() const {
  655.     return getParsedSpecifiers() == DeclSpec::PQ_None;
  656.   }
  657.  
  658.   void SetRangeStart(SourceLocation Loc) { Range.setBegin(Loc); }
  659.   void SetRangeEnd(SourceLocation Loc) { Range.setEnd(Loc); }
  660.  
  661.   /// These methods set the specified attribute of the DeclSpec and
  662.   /// return false if there was no error.  If an error occurs (for
  663.   /// example, if we tried to set "auto" on a spec with "extern"
  664.   /// already set), they return true and set PrevSpec and DiagID
  665.   /// such that
  666.   ///   Diag(Loc, DiagID) << PrevSpec;
  667.   /// will yield a useful result.
  668.   ///
  669.   /// TODO: use a more general approach that still allows these
  670.   /// diagnostics to be ignored when desired.
  671.   bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
  672.                            const char *&PrevSpec, unsigned &DiagID,
  673.                            const PrintingPolicy &Policy);
  674.   bool SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc,
  675.                                  const char *&PrevSpec, unsigned &DiagID);
  676.   bool SetTypeSpecWidth(TypeSpecifierWidth W, SourceLocation Loc,
  677.                         const char *&PrevSpec, unsigned &DiagID,
  678.                         const PrintingPolicy &Policy);
  679.   bool SetTypeSpecComplex(TSC C, SourceLocation Loc, const char *&PrevSpec,
  680.                           unsigned &DiagID);
  681.   bool SetTypeSpecSign(TypeSpecifierSign S, SourceLocation Loc,
  682.                        const char *&PrevSpec, unsigned &DiagID);
  683.   bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
  684.                        unsigned &DiagID, const PrintingPolicy &Policy);
  685.   bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
  686.                        unsigned &DiagID, ParsedType Rep,
  687.                        const PrintingPolicy &Policy);
  688.   bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
  689.                        unsigned &DiagID, TypeResult Rep,
  690.                        const PrintingPolicy &Policy) {
  691.     if (Rep.isInvalid())
  692.       return SetTypeSpecError();
  693.     return SetTypeSpecType(T, Loc, PrevSpec, DiagID, Rep.get(), Policy);
  694.   }
  695.   bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
  696.                        unsigned &DiagID, Decl *Rep, bool Owned,
  697.                        const PrintingPolicy &Policy);
  698.   bool SetTypeSpecType(TST T, SourceLocation TagKwLoc,
  699.                        SourceLocation TagNameLoc, const char *&PrevSpec,
  700.                        unsigned &DiagID, ParsedType Rep,
  701.                        const PrintingPolicy &Policy);
  702.   bool SetTypeSpecType(TST T, SourceLocation TagKwLoc,
  703.                        SourceLocation TagNameLoc, const char *&PrevSpec,
  704.                        unsigned &DiagID, Decl *Rep, bool Owned,
  705.                        const PrintingPolicy &Policy);
  706.   bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
  707.                        unsigned &DiagID, TemplateIdAnnotation *Rep,
  708.                        const PrintingPolicy &Policy);
  709.  
  710.   bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
  711.                        unsigned &DiagID, Expr *Rep,
  712.                        const PrintingPolicy &policy);
  713.   bool SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
  714.                        const char *&PrevSpec, unsigned &DiagID,
  715.                        const PrintingPolicy &Policy);
  716.   bool SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
  717.                        const char *&PrevSpec, unsigned &DiagID,
  718.                        const PrintingPolicy &Policy);
  719.   bool SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
  720.                        const char *&PrevSpec, unsigned &DiagID,
  721.                        const PrintingPolicy &Policy);
  722.   bool SetTypePipe(bool isPipe, SourceLocation Loc,
  723.                        const char *&PrevSpec, unsigned &DiagID,
  724.                        const PrintingPolicy &Policy);
  725.   bool SetBitIntType(SourceLocation KWLoc, Expr *BitWidth,
  726.                      const char *&PrevSpec, unsigned &DiagID,
  727.                      const PrintingPolicy &Policy);
  728.   bool SetTypeSpecSat(SourceLocation Loc, const char *&PrevSpec,
  729.                       unsigned &DiagID);
  730.   bool SetTypeSpecError();
  731.   void UpdateDeclRep(Decl *Rep) {
  732.     assert(isDeclRep((TST) TypeSpecType));
  733.     DeclRep = Rep;
  734.   }
  735.   void UpdateTypeRep(ParsedType Rep) {
  736.     assert(isTypeRep((TST) TypeSpecType));
  737.     TypeRep = Rep;
  738.   }
  739.   void UpdateExprRep(Expr *Rep) {
  740.     assert(isExprRep((TST) TypeSpecType));
  741.     ExprRep = Rep;
  742.   }
  743.  
  744.   bool SetTypeQual(TQ T, SourceLocation Loc);
  745.  
  746.   bool SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
  747.                    unsigned &DiagID, const LangOptions &Lang);
  748.  
  749.   bool setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
  750.                              unsigned &DiagID);
  751.   bool setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
  752.                                   unsigned &DiagID);
  753.   bool setFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec,
  754.                               unsigned &DiagID);
  755.   bool setFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec,
  756.                                unsigned &DiagID, ExplicitSpecifier ExplicitSpec,
  757.                                SourceLocation CloseParenLoc);
  758.   bool setFunctionSpecNoreturn(SourceLocation Loc, const char *&PrevSpec,
  759.                                unsigned &DiagID);
  760.  
  761.   bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
  762.                      unsigned &DiagID);
  763.   bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
  764.                             unsigned &DiagID);
  765.   bool SetConstexprSpec(ConstexprSpecKind ConstexprKind, SourceLocation Loc,
  766.                         const char *&PrevSpec, unsigned &DiagID);
  767.  
  768.   FriendSpecified isFriendSpecified() const {
  769.     return static_cast<FriendSpecified>(Friend_specified);
  770.   }
  771.  
  772.   SourceLocation getFriendSpecLoc() const { return FriendLoc; }
  773.  
  774.   bool isModulePrivateSpecified() const { return ModulePrivateLoc.isValid(); }
  775.   SourceLocation getModulePrivateSpecLoc() const { return ModulePrivateLoc; }
  776.  
  777.   ConstexprSpecKind getConstexprSpecifier() const {
  778.     return ConstexprSpecKind(ConstexprSpecifier);
  779.   }
  780.  
  781.   SourceLocation getConstexprSpecLoc() const { return ConstexprLoc; }
  782.   bool hasConstexprSpecifier() const {
  783.     return getConstexprSpecifier() != ConstexprSpecKind::Unspecified;
  784.   }
  785.  
  786.   void ClearConstexprSpec() {
  787.     ConstexprSpecifier = static_cast<unsigned>(ConstexprSpecKind::Unspecified);
  788.     ConstexprLoc = SourceLocation();
  789.   }
  790.  
  791.   AttributePool &getAttributePool() const {
  792.     return Attrs.getPool();
  793.   }
  794.  
  795.   /// Concatenates two attribute lists.
  796.   ///
  797.   /// The GCC attribute syntax allows for the following:
  798.   ///
  799.   /// \code
  800.   /// short __attribute__(( unused, deprecated ))
  801.   /// int __attribute__(( may_alias, aligned(16) )) var;
  802.   /// \endcode
  803.   ///
  804.   /// This declares 4 attributes using 2 lists. The following syntax is
  805.   /// also allowed and equivalent to the previous declaration.
  806.   ///
  807.   /// \code
  808.   /// short __attribute__((unused)) __attribute__((deprecated))
  809.   /// int __attribute__((may_alias)) __attribute__((aligned(16))) var;
  810.   /// \endcode
  811.   ///
  812.   void addAttributes(const ParsedAttributesView &AL) {
  813.     Attrs.addAll(AL.begin(), AL.end());
  814.   }
  815.  
  816.   bool hasAttributes() const { return !Attrs.empty(); }
  817.  
  818.   ParsedAttributes &getAttributes() { return Attrs; }
  819.   const ParsedAttributes &getAttributes() const { return Attrs; }
  820.  
  821.   void takeAttributesFrom(ParsedAttributes &attrs) {
  822.     Attrs.takeAllFrom(attrs);
  823.   }
  824.  
  825.   /// Finish - This does final analysis of the declspec, issuing diagnostics for
  826.   /// things like "_Imaginary" (lacking an FP type).  After calling this method,
  827.   /// DeclSpec is guaranteed self-consistent, even if an error occurred.
  828.   void Finish(Sema &S, const PrintingPolicy &Policy);
  829.  
  830.   const WrittenBuiltinSpecs& getWrittenBuiltinSpecs() const {
  831.     return writtenBS;
  832.   }
  833.  
  834.   ObjCDeclSpec *getObjCQualifiers() const { return ObjCQualifiers; }
  835.   void setObjCQualifiers(ObjCDeclSpec *quals) { ObjCQualifiers = quals; }
  836.  
  837.   /// Checks if this DeclSpec can stand alone, without a Declarator.
  838.   ///
  839.   /// Only tag declspecs can stand alone.
  840.   bool isMissingDeclaratorOk();
  841. };
  842.  
  843. /// Captures information about "declaration specifiers" specific to
  844. /// Objective-C.
  845. class ObjCDeclSpec {
  846. public:
  847.   /// ObjCDeclQualifier - Qualifier used on types in method
  848.   /// declarations.  Not all combinations are sensible.  Parameters
  849.   /// can be one of { in, out, inout } with one of { bycopy, byref }.
  850.   /// Returns can either be { oneway } or not.
  851.   ///
  852.   /// This should be kept in sync with Decl::ObjCDeclQualifier.
  853.   enum ObjCDeclQualifier {
  854.     DQ_None = 0x0,
  855.     DQ_In = 0x1,
  856.     DQ_Inout = 0x2,
  857.     DQ_Out = 0x4,
  858.     DQ_Bycopy = 0x8,
  859.     DQ_Byref = 0x10,
  860.     DQ_Oneway = 0x20,
  861.     DQ_CSNullability = 0x40
  862.   };
  863.  
  864.   ObjCDeclSpec()
  865.       : objcDeclQualifier(DQ_None),
  866.         PropertyAttributes(ObjCPropertyAttribute::kind_noattr), Nullability(0),
  867.         GetterName(nullptr), SetterName(nullptr) {}
  868.  
  869.   ObjCDeclQualifier getObjCDeclQualifier() const {
  870.     return (ObjCDeclQualifier)objcDeclQualifier;
  871.   }
  872.   void setObjCDeclQualifier(ObjCDeclQualifier DQVal) {
  873.     objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier | DQVal);
  874.   }
  875.   void clearObjCDeclQualifier(ObjCDeclQualifier DQVal) {
  876.     objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier & ~DQVal);
  877.   }
  878.  
  879.   ObjCPropertyAttribute::Kind getPropertyAttributes() const {
  880.     return ObjCPropertyAttribute::Kind(PropertyAttributes);
  881.   }
  882.   void setPropertyAttributes(ObjCPropertyAttribute::Kind PRVal) {
  883.     PropertyAttributes =
  884.         (ObjCPropertyAttribute::Kind)(PropertyAttributes | PRVal);
  885.   }
  886.  
  887.   NullabilityKind getNullability() const {
  888.     assert(
  889.         ((getObjCDeclQualifier() & DQ_CSNullability) ||
  890.          (getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)) &&
  891.         "Objective-C declspec doesn't have nullability");
  892.     return static_cast<NullabilityKind>(Nullability);
  893.   }
  894.  
  895.   SourceLocation getNullabilityLoc() const {
  896.     assert(
  897.         ((getObjCDeclQualifier() & DQ_CSNullability) ||
  898.          (getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)) &&
  899.         "Objective-C declspec doesn't have nullability");
  900.     return NullabilityLoc;
  901.   }
  902.  
  903.   void setNullability(SourceLocation loc, NullabilityKind kind) {
  904.     assert(
  905.         ((getObjCDeclQualifier() & DQ_CSNullability) ||
  906.          (getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)) &&
  907.         "Set the nullability declspec or property attribute first");
  908.     Nullability = static_cast<unsigned>(kind);
  909.     NullabilityLoc = loc;
  910.   }
  911.  
  912.   const IdentifierInfo *getGetterName() const { return GetterName; }
  913.   IdentifierInfo *getGetterName() { return GetterName; }
  914.   SourceLocation getGetterNameLoc() const { return GetterNameLoc; }
  915.   void setGetterName(IdentifierInfo *name, SourceLocation loc) {
  916.     GetterName = name;
  917.     GetterNameLoc = loc;
  918.   }
  919.  
  920.   const IdentifierInfo *getSetterName() const { return SetterName; }
  921.   IdentifierInfo *getSetterName() { return SetterName; }
  922.   SourceLocation getSetterNameLoc() const { return SetterNameLoc; }
  923.   void setSetterName(IdentifierInfo *name, SourceLocation loc) {
  924.     SetterName = name;
  925.     SetterNameLoc = loc;
  926.   }
  927.  
  928. private:
  929.   // FIXME: These two are unrelated and mutually exclusive. So perhaps
  930.   // we can put them in a union to reflect their mutual exclusivity
  931.   // (space saving is negligible).
  932.   unsigned objcDeclQualifier : 7;
  933.  
  934.   // NOTE: VC++ treats enums as signed, avoid using ObjCPropertyAttribute::Kind
  935.   unsigned PropertyAttributes : NumObjCPropertyAttrsBits;
  936.  
  937.   unsigned Nullability : 2;
  938.  
  939.   SourceLocation NullabilityLoc;
  940.  
  941.   IdentifierInfo *GetterName;    // getter name or NULL if no getter
  942.   IdentifierInfo *SetterName;    // setter name or NULL if no setter
  943.   SourceLocation GetterNameLoc; // location of the getter attribute's value
  944.   SourceLocation SetterNameLoc; // location of the setter attribute's value
  945.  
  946. };
  947.  
  948. /// Describes the kind of unqualified-id parsed.
  949. enum class UnqualifiedIdKind {
  950.   /// An identifier.
  951.   IK_Identifier,
  952.   /// An overloaded operator name, e.g., operator+.
  953.   IK_OperatorFunctionId,
  954.   /// A conversion function name, e.g., operator int.
  955.   IK_ConversionFunctionId,
  956.   /// A user-defined literal name, e.g., operator "" _i.
  957.   IK_LiteralOperatorId,
  958.   /// A constructor name.
  959.   IK_ConstructorName,
  960.   /// A constructor named via a template-id.
  961.   IK_ConstructorTemplateId,
  962.   /// A destructor name.
  963.   IK_DestructorName,
  964.   /// A template-id, e.g., f<int>.
  965.   IK_TemplateId,
  966.   /// An implicit 'self' parameter
  967.   IK_ImplicitSelfParam,
  968.   /// A deduction-guide name (a template-name)
  969.   IK_DeductionGuideName
  970. };
  971.  
  972. /// Represents a C++ unqualified-id that has been parsed.
  973. class UnqualifiedId {
  974. private:
  975.   UnqualifiedId(const UnqualifiedId &Other) = delete;
  976.   const UnqualifiedId &operator=(const UnqualifiedId &) = delete;
  977.  
  978.   /// Describes the kind of unqualified-id parsed.
  979.   UnqualifiedIdKind Kind;
  980.  
  981. public:
  982.   struct OFI {
  983.     /// The kind of overloaded operator.
  984.     OverloadedOperatorKind Operator;
  985.  
  986.     /// The source locations of the individual tokens that name
  987.     /// the operator, e.g., the "new", "[", and "]" tokens in
  988.     /// operator new [].
  989.     ///
  990.     /// Different operators have different numbers of tokens in their name,
  991.     /// up to three. Any remaining source locations in this array will be
  992.     /// set to an invalid value for operators with fewer than three tokens.
  993.     SourceLocation SymbolLocations[3];
  994.   };
  995.  
  996.   /// Anonymous union that holds extra data associated with the
  997.   /// parsed unqualified-id.
  998.   union {
  999.     /// When Kind == IK_Identifier, the parsed identifier, or when
  1000.     /// Kind == IK_UserLiteralId, the identifier suffix.
  1001.     IdentifierInfo *Identifier;
  1002.  
  1003.     /// When Kind == IK_OperatorFunctionId, the overloaded operator
  1004.     /// that we parsed.
  1005.     struct OFI OperatorFunctionId;
  1006.  
  1007.     /// When Kind == IK_ConversionFunctionId, the type that the
  1008.     /// conversion function names.
  1009.     UnionParsedType ConversionFunctionId;
  1010.  
  1011.     /// When Kind == IK_ConstructorName, the class-name of the type
  1012.     /// whose constructor is being referenced.
  1013.     UnionParsedType ConstructorName;
  1014.  
  1015.     /// When Kind == IK_DestructorName, the type referred to by the
  1016.     /// class-name.
  1017.     UnionParsedType DestructorName;
  1018.  
  1019.     /// When Kind == IK_DeductionGuideName, the parsed template-name.
  1020.     UnionParsedTemplateTy TemplateName;
  1021.  
  1022.     /// When Kind == IK_TemplateId or IK_ConstructorTemplateId,
  1023.     /// the template-id annotation that contains the template name and
  1024.     /// template arguments.
  1025.     TemplateIdAnnotation *TemplateId;
  1026.   };
  1027.  
  1028.   /// The location of the first token that describes this unqualified-id,
  1029.   /// which will be the location of the identifier, "operator" keyword,
  1030.   /// tilde (for a destructor), or the template name of a template-id.
  1031.   SourceLocation StartLocation;
  1032.  
  1033.   /// The location of the last token that describes this unqualified-id.
  1034.   SourceLocation EndLocation;
  1035.  
  1036.   UnqualifiedId()
  1037.       : Kind(UnqualifiedIdKind::IK_Identifier), Identifier(nullptr) {}
  1038.  
  1039.   /// Clear out this unqualified-id, setting it to default (invalid)
  1040.   /// state.
  1041.   void clear() {
  1042.     Kind = UnqualifiedIdKind::IK_Identifier;
  1043.     Identifier = nullptr;
  1044.     StartLocation = SourceLocation();
  1045.     EndLocation = SourceLocation();
  1046.   }
  1047.  
  1048.   /// Determine whether this unqualified-id refers to a valid name.
  1049.   bool isValid() const { return StartLocation.isValid(); }
  1050.  
  1051.   /// Determine whether this unqualified-id refers to an invalid name.
  1052.   bool isInvalid() const { return !isValid(); }
  1053.  
  1054.   /// Determine what kind of name we have.
  1055.   UnqualifiedIdKind getKind() const { return Kind; }
  1056.  
  1057.   /// Specify that this unqualified-id was parsed as an identifier.
  1058.   ///
  1059.   /// \param Id the parsed identifier.
  1060.   /// \param IdLoc the location of the parsed identifier.
  1061.   void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc) {
  1062.     Kind = UnqualifiedIdKind::IK_Identifier;
  1063.     Identifier = const_cast<IdentifierInfo *>(Id);
  1064.     StartLocation = EndLocation = IdLoc;
  1065.   }
  1066.  
  1067.   /// Specify that this unqualified-id was parsed as an
  1068.   /// operator-function-id.
  1069.   ///
  1070.   /// \param OperatorLoc the location of the 'operator' keyword.
  1071.   ///
  1072.   /// \param Op the overloaded operator.
  1073.   ///
  1074.   /// \param SymbolLocations the locations of the individual operator symbols
  1075.   /// in the operator.
  1076.   void setOperatorFunctionId(SourceLocation OperatorLoc,
  1077.                              OverloadedOperatorKind Op,
  1078.                              SourceLocation SymbolLocations[3]);
  1079.  
  1080.   /// Specify that this unqualified-id was parsed as a
  1081.   /// conversion-function-id.
  1082.   ///
  1083.   /// \param OperatorLoc the location of the 'operator' keyword.
  1084.   ///
  1085.   /// \param Ty the type to which this conversion function is converting.
  1086.   ///
  1087.   /// \param EndLoc the location of the last token that makes up the type name.
  1088.   void setConversionFunctionId(SourceLocation OperatorLoc,
  1089.                                ParsedType Ty,
  1090.                                SourceLocation EndLoc) {
  1091.     Kind = UnqualifiedIdKind::IK_ConversionFunctionId;
  1092.     StartLocation = OperatorLoc;
  1093.     EndLocation = EndLoc;
  1094.     ConversionFunctionId = Ty;
  1095.   }
  1096.  
  1097.   /// Specific that this unqualified-id was parsed as a
  1098.   /// literal-operator-id.
  1099.   ///
  1100.   /// \param Id the parsed identifier.
  1101.   ///
  1102.   /// \param OpLoc the location of the 'operator' keyword.
  1103.   ///
  1104.   /// \param IdLoc the location of the identifier.
  1105.   void setLiteralOperatorId(const IdentifierInfo *Id, SourceLocation OpLoc,
  1106.                               SourceLocation IdLoc) {
  1107.     Kind = UnqualifiedIdKind::IK_LiteralOperatorId;
  1108.     Identifier = const_cast<IdentifierInfo *>(Id);
  1109.     StartLocation = OpLoc;
  1110.     EndLocation = IdLoc;
  1111.   }
  1112.  
  1113.   /// Specify that this unqualified-id was parsed as a constructor name.
  1114.   ///
  1115.   /// \param ClassType the class type referred to by the constructor name.
  1116.   ///
  1117.   /// \param ClassNameLoc the location of the class name.
  1118.   ///
  1119.   /// \param EndLoc the location of the last token that makes up the type name.
  1120.   void setConstructorName(ParsedType ClassType,
  1121.                           SourceLocation ClassNameLoc,
  1122.                           SourceLocation EndLoc) {
  1123.     Kind = UnqualifiedIdKind::IK_ConstructorName;
  1124.     StartLocation = ClassNameLoc;
  1125.     EndLocation = EndLoc;
  1126.     ConstructorName = ClassType;
  1127.   }
  1128.  
  1129.   /// Specify that this unqualified-id was parsed as a
  1130.   /// template-id that names a constructor.
  1131.   ///
  1132.   /// \param TemplateId the template-id annotation that describes the parsed
  1133.   /// template-id. This UnqualifiedId instance will take ownership of the
  1134.   /// \p TemplateId and will free it on destruction.
  1135.   void setConstructorTemplateId(TemplateIdAnnotation *TemplateId);
  1136.  
  1137.   /// Specify that this unqualified-id was parsed as a destructor name.
  1138.   ///
  1139.   /// \param TildeLoc the location of the '~' that introduces the destructor
  1140.   /// name.
  1141.   ///
  1142.   /// \param ClassType the name of the class referred to by the destructor name.
  1143.   void setDestructorName(SourceLocation TildeLoc,
  1144.                          ParsedType ClassType,
  1145.                          SourceLocation EndLoc) {
  1146.     Kind = UnqualifiedIdKind::IK_DestructorName;
  1147.     StartLocation = TildeLoc;
  1148.     EndLocation = EndLoc;
  1149.     DestructorName = ClassType;
  1150.   }
  1151.  
  1152.   /// Specify that this unqualified-id was parsed as a template-id.
  1153.   ///
  1154.   /// \param TemplateId the template-id annotation that describes the parsed
  1155.   /// template-id. This UnqualifiedId instance will take ownership of the
  1156.   /// \p TemplateId and will free it on destruction.
  1157.   void setTemplateId(TemplateIdAnnotation *TemplateId);
  1158.  
  1159.   /// Specify that this unqualified-id was parsed as a template-name for
  1160.   /// a deduction-guide.
  1161.   ///
  1162.   /// \param Template The parsed template-name.
  1163.   /// \param TemplateLoc The location of the parsed template-name.
  1164.   void setDeductionGuideName(ParsedTemplateTy Template,
  1165.                              SourceLocation TemplateLoc) {
  1166.     Kind = UnqualifiedIdKind::IK_DeductionGuideName;
  1167.     TemplateName = Template;
  1168.     StartLocation = EndLocation = TemplateLoc;
  1169.   }
  1170.  
  1171.   /// Specify that this unqualified-id is an implicit 'self'
  1172.   /// parameter.
  1173.   ///
  1174.   /// \param Id the identifier.
  1175.   void setImplicitSelfParam(const IdentifierInfo *Id) {
  1176.     Kind = UnqualifiedIdKind::IK_ImplicitSelfParam;
  1177.     Identifier = const_cast<IdentifierInfo *>(Id);
  1178.     StartLocation = EndLocation = SourceLocation();
  1179.   }
  1180.  
  1181.   /// Return the source range that covers this unqualified-id.
  1182.   SourceRange getSourceRange() const LLVM_READONLY {
  1183.     return SourceRange(StartLocation, EndLocation);
  1184.   }
  1185.   SourceLocation getBeginLoc() const LLVM_READONLY { return StartLocation; }
  1186.   SourceLocation getEndLoc() const LLVM_READONLY { return EndLocation; }
  1187. };
  1188.  
  1189. /// A set of tokens that has been cached for later parsing.
  1190. typedef SmallVector<Token, 4> CachedTokens;
  1191.  
  1192. /// One instance of this struct is used for each type in a
  1193. /// declarator that is parsed.
  1194. ///
  1195. /// This is intended to be a small value object.
  1196. struct DeclaratorChunk {
  1197.   DeclaratorChunk() {};
  1198.  
  1199.   enum {
  1200.     Pointer, Reference, Array, Function, BlockPointer, MemberPointer, Paren, Pipe
  1201.   } Kind;
  1202.  
  1203.   /// Loc - The place where this type was defined.
  1204.   SourceLocation Loc;
  1205.   /// EndLoc - If valid, the place where this chunck ends.
  1206.   SourceLocation EndLoc;
  1207.  
  1208.   SourceRange getSourceRange() const {
  1209.     if (EndLoc.isInvalid())
  1210.       return SourceRange(Loc, Loc);
  1211.     return SourceRange(Loc, EndLoc);
  1212.   }
  1213.  
  1214.   ParsedAttributesView AttrList;
  1215.  
  1216.   struct PointerTypeInfo {
  1217.     /// The type qualifiers: const/volatile/restrict/unaligned/atomic.
  1218.     unsigned TypeQuals : 5;
  1219.  
  1220.     /// The location of the const-qualifier, if any.
  1221.     SourceLocation ConstQualLoc;
  1222.  
  1223.     /// The location of the volatile-qualifier, if any.
  1224.     SourceLocation VolatileQualLoc;
  1225.  
  1226.     /// The location of the restrict-qualifier, if any.
  1227.     SourceLocation RestrictQualLoc;
  1228.  
  1229.     /// The location of the _Atomic-qualifier, if any.
  1230.     SourceLocation AtomicQualLoc;
  1231.  
  1232.     /// The location of the __unaligned-qualifier, if any.
  1233.     SourceLocation UnalignedQualLoc;
  1234.  
  1235.     void destroy() {
  1236.     }
  1237.   };
  1238.  
  1239.   struct ReferenceTypeInfo {
  1240.     /// The type qualifier: restrict. [GNU] C++ extension
  1241.     bool HasRestrict : 1;
  1242.     /// True if this is an lvalue reference, false if it's an rvalue reference.
  1243.     bool LValueRef : 1;
  1244.     void destroy() {
  1245.     }
  1246.   };
  1247.  
  1248.   struct ArrayTypeInfo {
  1249.     /// The type qualifiers for the array:
  1250.     /// const/volatile/restrict/__unaligned/_Atomic.
  1251.     unsigned TypeQuals : 5;
  1252.  
  1253.     /// True if this dimension included the 'static' keyword.
  1254.     unsigned hasStatic : 1;
  1255.  
  1256.     /// True if this dimension was [*].  In this case, NumElts is null.
  1257.     unsigned isStar : 1;
  1258.  
  1259.     /// This is the size of the array, or null if [] or [*] was specified.
  1260.     /// Since the parser is multi-purpose, and we don't want to impose a root
  1261.     /// expression class on all clients, NumElts is untyped.
  1262.     Expr *NumElts;
  1263.  
  1264.     void destroy() {}
  1265.   };
  1266.  
  1267.   /// ParamInfo - An array of paraminfo objects is allocated whenever a function
  1268.   /// declarator is parsed.  There are two interesting styles of parameters
  1269.   /// here:
  1270.   /// K&R-style identifier lists and parameter type lists.  K&R-style identifier
  1271.   /// lists will have information about the identifier, but no type information.
  1272.   /// Parameter type lists will have type info (if the actions module provides
  1273.   /// it), but may have null identifier info: e.g. for 'void foo(int X, int)'.
  1274.   struct ParamInfo {
  1275.     IdentifierInfo *Ident;
  1276.     SourceLocation IdentLoc;
  1277.     Decl *Param;
  1278.  
  1279.     /// DefaultArgTokens - When the parameter's default argument
  1280.     /// cannot be parsed immediately (because it occurs within the
  1281.     /// declaration of a member function), it will be stored here as a
  1282.     /// sequence of tokens to be parsed once the class definition is
  1283.     /// complete. Non-NULL indicates that there is a default argument.
  1284.     std::unique_ptr<CachedTokens> DefaultArgTokens;
  1285.  
  1286.     ParamInfo() = default;
  1287.     ParamInfo(IdentifierInfo *ident, SourceLocation iloc,
  1288.               Decl *param,
  1289.               std::unique_ptr<CachedTokens> DefArgTokens = nullptr)
  1290.       : Ident(ident), IdentLoc(iloc), Param(param),
  1291.         DefaultArgTokens(std::move(DefArgTokens)) {}
  1292.   };
  1293.  
  1294.   struct TypeAndRange {
  1295.     ParsedType Ty;
  1296.     SourceRange Range;
  1297.   };
  1298.  
  1299.   struct FunctionTypeInfo {
  1300.     /// hasPrototype - This is true if the function had at least one typed
  1301.     /// parameter.  If the function is () or (a,b,c), then it has no prototype,
  1302.     /// and is treated as a K&R-style function.
  1303.     unsigned hasPrototype : 1;
  1304.  
  1305.     /// isVariadic - If this function has a prototype, and if that
  1306.     /// proto ends with ',...)', this is true. When true, EllipsisLoc
  1307.     /// contains the location of the ellipsis.
  1308.     unsigned isVariadic : 1;
  1309.  
  1310.     /// Can this declaration be a constructor-style initializer?
  1311.     unsigned isAmbiguous : 1;
  1312.  
  1313.     /// Whether the ref-qualifier (if any) is an lvalue reference.
  1314.     /// Otherwise, it's an rvalue reference.
  1315.     unsigned RefQualifierIsLValueRef : 1;
  1316.  
  1317.     /// ExceptionSpecType - An ExceptionSpecificationType value.
  1318.     unsigned ExceptionSpecType : 4;
  1319.  
  1320.     /// DeleteParams - If this is true, we need to delete[] Params.
  1321.     unsigned DeleteParams : 1;
  1322.  
  1323.     /// HasTrailingReturnType - If this is true, a trailing return type was
  1324.     /// specified.
  1325.     unsigned HasTrailingReturnType : 1;
  1326.  
  1327.     /// The location of the left parenthesis in the source.
  1328.     SourceLocation LParenLoc;
  1329.  
  1330.     /// When isVariadic is true, the location of the ellipsis in the source.
  1331.     SourceLocation EllipsisLoc;
  1332.  
  1333.     /// The location of the right parenthesis in the source.
  1334.     SourceLocation RParenLoc;
  1335.  
  1336.     /// NumParams - This is the number of formal parameters specified by the
  1337.     /// declarator.
  1338.     unsigned NumParams;
  1339.  
  1340.     /// NumExceptionsOrDecls - This is the number of types in the
  1341.     /// dynamic-exception-decl, if the function has one. In C, this is the
  1342.     /// number of declarations in the function prototype.
  1343.     unsigned NumExceptionsOrDecls;
  1344.  
  1345.     /// The location of the ref-qualifier, if any.
  1346.     ///
  1347.     /// If this is an invalid location, there is no ref-qualifier.
  1348.     SourceLocation RefQualifierLoc;
  1349.  
  1350.     /// The location of the 'mutable' qualifer in a lambda-declarator, if
  1351.     /// any.
  1352.     SourceLocation MutableLoc;
  1353.  
  1354.     /// The beginning location of the exception specification, if any.
  1355.     SourceLocation ExceptionSpecLocBeg;
  1356.  
  1357.     /// The end location of the exception specification, if any.
  1358.     SourceLocation ExceptionSpecLocEnd;
  1359.  
  1360.     /// Params - This is a pointer to a new[]'d array of ParamInfo objects that
  1361.     /// describe the parameters specified by this function declarator.  null if
  1362.     /// there are no parameters specified.
  1363.     ParamInfo *Params;
  1364.  
  1365.     /// DeclSpec for the function with the qualifier related info.
  1366.     DeclSpec *MethodQualifiers;
  1367.  
  1368.     /// AttributeFactory for the MethodQualifiers.
  1369.     AttributeFactory *QualAttrFactory;
  1370.  
  1371.     union {
  1372.       /// Pointer to a new[]'d array of TypeAndRange objects that
  1373.       /// contain the types in the function's dynamic exception specification
  1374.       /// and their locations, if there is one.
  1375.       TypeAndRange *Exceptions;
  1376.  
  1377.       /// Pointer to the expression in the noexcept-specifier of this
  1378.       /// function, if it has one.
  1379.       Expr *NoexceptExpr;
  1380.  
  1381.       /// Pointer to the cached tokens for an exception-specification
  1382.       /// that has not yet been parsed.
  1383.       CachedTokens *ExceptionSpecTokens;
  1384.  
  1385.       /// Pointer to a new[]'d array of declarations that need to be available
  1386.       /// for lookup inside the function body, if one exists. Does not exist in
  1387.       /// C++.
  1388.       NamedDecl **DeclsInPrototype;
  1389.     };
  1390.  
  1391.     /// If HasTrailingReturnType is true, this is the trailing return
  1392.     /// type specified.
  1393.     UnionParsedType TrailingReturnType;
  1394.  
  1395.     /// If HasTrailingReturnType is true, this is the location of the trailing
  1396.     /// return type.
  1397.     SourceLocation TrailingReturnTypeLoc;
  1398.  
  1399.     /// Reset the parameter list to having zero parameters.
  1400.     ///
  1401.     /// This is used in various places for error recovery.
  1402.     void freeParams() {
  1403.       for (unsigned I = 0; I < NumParams; ++I)
  1404.         Params[I].DefaultArgTokens.reset();
  1405.       if (DeleteParams) {
  1406.         delete[] Params;
  1407.         DeleteParams = false;
  1408.       }
  1409.       NumParams = 0;
  1410.     }
  1411.  
  1412.     void destroy() {
  1413.       freeParams();
  1414.       delete QualAttrFactory;
  1415.       delete MethodQualifiers;
  1416.       switch (getExceptionSpecType()) {
  1417.       default:
  1418.         break;
  1419.       case EST_Dynamic:
  1420.         delete[] Exceptions;
  1421.         break;
  1422.       case EST_Unparsed:
  1423.         delete ExceptionSpecTokens;
  1424.         break;
  1425.       case EST_None:
  1426.         if (NumExceptionsOrDecls != 0)
  1427.           delete[] DeclsInPrototype;
  1428.         break;
  1429.       }
  1430.     }
  1431.  
  1432.     DeclSpec &getOrCreateMethodQualifiers() {
  1433.       if (!MethodQualifiers) {
  1434.         QualAttrFactory = new AttributeFactory();
  1435.         MethodQualifiers = new DeclSpec(*QualAttrFactory);
  1436.       }
  1437.       return *MethodQualifiers;
  1438.     }
  1439.  
  1440.     /// isKNRPrototype - Return true if this is a K&R style identifier list,
  1441.     /// like "void foo(a,b,c)".  In a function definition, this will be followed
  1442.     /// by the parameter type definitions.
  1443.     bool isKNRPrototype() const { return !hasPrototype && NumParams != 0; }
  1444.  
  1445.     SourceLocation getLParenLoc() const { return LParenLoc; }
  1446.  
  1447.     SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
  1448.  
  1449.     SourceLocation getRParenLoc() const { return RParenLoc; }
  1450.  
  1451.     SourceLocation getExceptionSpecLocBeg() const {
  1452.       return ExceptionSpecLocBeg;
  1453.     }
  1454.  
  1455.     SourceLocation getExceptionSpecLocEnd() const {
  1456.       return ExceptionSpecLocEnd;
  1457.     }
  1458.  
  1459.     SourceRange getExceptionSpecRange() const {
  1460.       return SourceRange(getExceptionSpecLocBeg(), getExceptionSpecLocEnd());
  1461.     }
  1462.  
  1463.     /// Retrieve the location of the ref-qualifier, if any.
  1464.     SourceLocation getRefQualifierLoc() const { return RefQualifierLoc; }
  1465.  
  1466.     /// Retrieve the location of the 'const' qualifier.
  1467.     SourceLocation getConstQualifierLoc() const {
  1468.       assert(MethodQualifiers);
  1469.       return MethodQualifiers->getConstSpecLoc();
  1470.     }
  1471.  
  1472.     /// Retrieve the location of the 'volatile' qualifier.
  1473.     SourceLocation getVolatileQualifierLoc() const {
  1474.       assert(MethodQualifiers);
  1475.       return MethodQualifiers->getVolatileSpecLoc();
  1476.     }
  1477.  
  1478.     /// Retrieve the location of the 'restrict' qualifier.
  1479.     SourceLocation getRestrictQualifierLoc() const {
  1480.       assert(MethodQualifiers);
  1481.       return MethodQualifiers->getRestrictSpecLoc();
  1482.     }
  1483.  
  1484.     /// Retrieve the location of the 'mutable' qualifier, if any.
  1485.     SourceLocation getMutableLoc() const { return MutableLoc; }
  1486.  
  1487.     /// Determine whether this function declaration contains a
  1488.     /// ref-qualifier.
  1489.     bool hasRefQualifier() const { return getRefQualifierLoc().isValid(); }
  1490.  
  1491.     /// Determine whether this lambda-declarator contains a 'mutable'
  1492.     /// qualifier.
  1493.     bool hasMutableQualifier() const { return getMutableLoc().isValid(); }
  1494.  
  1495.     /// Determine whether this method has qualifiers.
  1496.     bool hasMethodTypeQualifiers() const {
  1497.       return MethodQualifiers && (MethodQualifiers->getTypeQualifiers() ||
  1498.                                   MethodQualifiers->getAttributes().size());
  1499.     }
  1500.  
  1501.     /// Get the type of exception specification this function has.
  1502.     ExceptionSpecificationType getExceptionSpecType() const {
  1503.       return static_cast<ExceptionSpecificationType>(ExceptionSpecType);
  1504.     }
  1505.  
  1506.     /// Get the number of dynamic exception specifications.
  1507.     unsigned getNumExceptions() const {
  1508.       assert(ExceptionSpecType != EST_None);
  1509.       return NumExceptionsOrDecls;
  1510.     }
  1511.  
  1512.     /// Get the non-parameter decls defined within this function
  1513.     /// prototype. Typically these are tag declarations.
  1514.     ArrayRef<NamedDecl *> getDeclsInPrototype() const {
  1515.       assert(ExceptionSpecType == EST_None);
  1516.       return llvm::ArrayRef(DeclsInPrototype, NumExceptionsOrDecls);
  1517.     }
  1518.  
  1519.     /// Determine whether this function declarator had a
  1520.     /// trailing-return-type.
  1521.     bool hasTrailingReturnType() const { return HasTrailingReturnType; }
  1522.  
  1523.     /// Get the trailing-return-type for this function declarator.
  1524.     ParsedType getTrailingReturnType() const {
  1525.       assert(HasTrailingReturnType);
  1526.       return TrailingReturnType;
  1527.     }
  1528.  
  1529.     /// Get the trailing-return-type location for this function declarator.
  1530.     SourceLocation getTrailingReturnTypeLoc() const {
  1531.       assert(HasTrailingReturnType);
  1532.       return TrailingReturnTypeLoc;
  1533.     }
  1534.   };
  1535.  
  1536.   struct BlockPointerTypeInfo {
  1537.     /// For now, sema will catch these as invalid.
  1538.     /// The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
  1539.     unsigned TypeQuals : 5;
  1540.  
  1541.     void destroy() {
  1542.     }
  1543.   };
  1544.  
  1545.   struct MemberPointerTypeInfo {
  1546.     /// The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
  1547.     unsigned TypeQuals : 5;
  1548.     /// Location of the '*' token.
  1549.     SourceLocation StarLoc;
  1550.     // CXXScopeSpec has a constructor, so it can't be a direct member.
  1551.     // So we need some pointer-aligned storage and a bit of trickery.
  1552.     alignas(CXXScopeSpec) char ScopeMem[sizeof(CXXScopeSpec)];
  1553.     CXXScopeSpec &Scope() {
  1554.       return *reinterpret_cast<CXXScopeSpec *>(ScopeMem);
  1555.     }
  1556.     const CXXScopeSpec &Scope() const {
  1557.       return *reinterpret_cast<const CXXScopeSpec *>(ScopeMem);
  1558.     }
  1559.     void destroy() {
  1560.       Scope().~CXXScopeSpec();
  1561.     }
  1562.   };
  1563.  
  1564.   struct PipeTypeInfo {
  1565.     /// The access writes.
  1566.     unsigned AccessWrites : 3;
  1567.  
  1568.     void destroy() {}
  1569.   };
  1570.  
  1571.   union {
  1572.     PointerTypeInfo       Ptr;
  1573.     ReferenceTypeInfo     Ref;
  1574.     ArrayTypeInfo         Arr;
  1575.     FunctionTypeInfo      Fun;
  1576.     BlockPointerTypeInfo  Cls;
  1577.     MemberPointerTypeInfo Mem;
  1578.     PipeTypeInfo          PipeInfo;
  1579.   };
  1580.  
  1581.   void destroy() {
  1582.     switch (Kind) {
  1583.     case DeclaratorChunk::Function:      return Fun.destroy();
  1584.     case DeclaratorChunk::Pointer:       return Ptr.destroy();
  1585.     case DeclaratorChunk::BlockPointer:  return Cls.destroy();
  1586.     case DeclaratorChunk::Reference:     return Ref.destroy();
  1587.     case DeclaratorChunk::Array:         return Arr.destroy();
  1588.     case DeclaratorChunk::MemberPointer: return Mem.destroy();
  1589.     case DeclaratorChunk::Paren:         return;
  1590.     case DeclaratorChunk::Pipe:          return PipeInfo.destroy();
  1591.     }
  1592.   }
  1593.  
  1594.   /// If there are attributes applied to this declaratorchunk, return
  1595.   /// them.
  1596.   const ParsedAttributesView &getAttrs() const { return AttrList; }
  1597.   ParsedAttributesView &getAttrs() { return AttrList; }
  1598.  
  1599.   /// Return a DeclaratorChunk for a pointer.
  1600.   static DeclaratorChunk getPointer(unsigned TypeQuals, SourceLocation Loc,
  1601.                                     SourceLocation ConstQualLoc,
  1602.                                     SourceLocation VolatileQualLoc,
  1603.                                     SourceLocation RestrictQualLoc,
  1604.                                     SourceLocation AtomicQualLoc,
  1605.                                     SourceLocation UnalignedQualLoc) {
  1606.     DeclaratorChunk I;
  1607.     I.Kind                = Pointer;
  1608.     I.Loc                 = Loc;
  1609.     new (&I.Ptr) PointerTypeInfo;
  1610.     I.Ptr.TypeQuals       = TypeQuals;
  1611.     I.Ptr.ConstQualLoc    = ConstQualLoc;
  1612.     I.Ptr.VolatileQualLoc = VolatileQualLoc;
  1613.     I.Ptr.RestrictQualLoc = RestrictQualLoc;
  1614.     I.Ptr.AtomicQualLoc   = AtomicQualLoc;
  1615.     I.Ptr.UnalignedQualLoc = UnalignedQualLoc;
  1616.     return I;
  1617.   }
  1618.  
  1619.   /// Return a DeclaratorChunk for a reference.
  1620.   static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc,
  1621.                                       bool lvalue) {
  1622.     DeclaratorChunk I;
  1623.     I.Kind            = Reference;
  1624.     I.Loc             = Loc;
  1625.     I.Ref.HasRestrict = (TypeQuals & DeclSpec::TQ_restrict) != 0;
  1626.     I.Ref.LValueRef   = lvalue;
  1627.     return I;
  1628.   }
  1629.  
  1630.   /// Return a DeclaratorChunk for an array.
  1631.   static DeclaratorChunk getArray(unsigned TypeQuals,
  1632.                                   bool isStatic, bool isStar, Expr *NumElts,
  1633.                                   SourceLocation LBLoc, SourceLocation RBLoc) {
  1634.     DeclaratorChunk I;
  1635.     I.Kind          = Array;
  1636.     I.Loc           = LBLoc;
  1637.     I.EndLoc        = RBLoc;
  1638.     I.Arr.TypeQuals = TypeQuals;
  1639.     I.Arr.hasStatic = isStatic;
  1640.     I.Arr.isStar    = isStar;
  1641.     I.Arr.NumElts   = NumElts;
  1642.     return I;
  1643.   }
  1644.  
  1645.   /// DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
  1646.   /// "TheDeclarator" is the declarator that this will be added to.
  1647.   static DeclaratorChunk getFunction(bool HasProto,
  1648.                                      bool IsAmbiguous,
  1649.                                      SourceLocation LParenLoc,
  1650.                                      ParamInfo *Params, unsigned NumParams,
  1651.                                      SourceLocation EllipsisLoc,
  1652.                                      SourceLocation RParenLoc,
  1653.                                      bool RefQualifierIsLvalueRef,
  1654.                                      SourceLocation RefQualifierLoc,
  1655.                                      SourceLocation MutableLoc,
  1656.                                      ExceptionSpecificationType ESpecType,
  1657.                                      SourceRange ESpecRange,
  1658.                                      ParsedType *Exceptions,
  1659.                                      SourceRange *ExceptionRanges,
  1660.                                      unsigned NumExceptions,
  1661.                                      Expr *NoexceptExpr,
  1662.                                      CachedTokens *ExceptionSpecTokens,
  1663.                                      ArrayRef<NamedDecl *> DeclsInPrototype,
  1664.                                      SourceLocation LocalRangeBegin,
  1665.                                      SourceLocation LocalRangeEnd,
  1666.                                      Declarator &TheDeclarator,
  1667.                                      TypeResult TrailingReturnType =
  1668.                                                     TypeResult(),
  1669.                                      SourceLocation TrailingReturnTypeLoc =
  1670.                                                     SourceLocation(),
  1671.                                      DeclSpec *MethodQualifiers = nullptr);
  1672.  
  1673.   /// Return a DeclaratorChunk for a block.
  1674.   static DeclaratorChunk getBlockPointer(unsigned TypeQuals,
  1675.                                          SourceLocation Loc) {
  1676.     DeclaratorChunk I;
  1677.     I.Kind          = BlockPointer;
  1678.     I.Loc           = Loc;
  1679.     I.Cls.TypeQuals = TypeQuals;
  1680.     return I;
  1681.   }
  1682.  
  1683.   /// Return a DeclaratorChunk for a block.
  1684.   static DeclaratorChunk getPipe(unsigned TypeQuals,
  1685.                                  SourceLocation Loc) {
  1686.     DeclaratorChunk I;
  1687.     I.Kind          = Pipe;
  1688.     I.Loc           = Loc;
  1689.     I.Cls.TypeQuals = TypeQuals;
  1690.     return I;
  1691.   }
  1692.  
  1693.   static DeclaratorChunk getMemberPointer(const CXXScopeSpec &SS,
  1694.                                           unsigned TypeQuals,
  1695.                                           SourceLocation StarLoc,
  1696.                                           SourceLocation EndLoc) {
  1697.     DeclaratorChunk I;
  1698.     I.Kind          = MemberPointer;
  1699.     I.Loc           = SS.getBeginLoc();
  1700.     I.EndLoc = EndLoc;
  1701.     new (&I.Mem) MemberPointerTypeInfo;
  1702.     I.Mem.StarLoc = StarLoc;
  1703.     I.Mem.TypeQuals = TypeQuals;
  1704.     new (I.Mem.ScopeMem) CXXScopeSpec(SS);
  1705.     return I;
  1706.   }
  1707.  
  1708.   /// Return a DeclaratorChunk for a paren.
  1709.   static DeclaratorChunk getParen(SourceLocation LParenLoc,
  1710.                                   SourceLocation RParenLoc) {
  1711.     DeclaratorChunk I;
  1712.     I.Kind          = Paren;
  1713.     I.Loc           = LParenLoc;
  1714.     I.EndLoc        = RParenLoc;
  1715.     return I;
  1716.   }
  1717.  
  1718.   bool isParen() const {
  1719.     return Kind == Paren;
  1720.   }
  1721. };
  1722.  
  1723. /// A parsed C++17 decomposition declarator of the form
  1724. ///   '[' identifier-list ']'
  1725. class DecompositionDeclarator {
  1726. public:
  1727.   struct Binding {
  1728.     IdentifierInfo *Name;
  1729.     SourceLocation NameLoc;
  1730.   };
  1731.  
  1732. private:
  1733.   /// The locations of the '[' and ']' tokens.
  1734.   SourceLocation LSquareLoc, RSquareLoc;
  1735.  
  1736.   /// The bindings.
  1737.   Binding *Bindings;
  1738.   unsigned NumBindings : 31;
  1739.   unsigned DeleteBindings : 1;
  1740.  
  1741.   friend class Declarator;
  1742.  
  1743. public:
  1744.   DecompositionDeclarator()
  1745.       : Bindings(nullptr), NumBindings(0), DeleteBindings(false) {}
  1746.   DecompositionDeclarator(const DecompositionDeclarator &G) = delete;
  1747.   DecompositionDeclarator &operator=(const DecompositionDeclarator &G) = delete;
  1748.   ~DecompositionDeclarator() {
  1749.     if (DeleteBindings)
  1750.       delete[] Bindings;
  1751.   }
  1752.  
  1753.   void clear() {
  1754.     LSquareLoc = RSquareLoc = SourceLocation();
  1755.     if (DeleteBindings)
  1756.       delete[] Bindings;
  1757.     Bindings = nullptr;
  1758.     NumBindings = 0;
  1759.     DeleteBindings = false;
  1760.   }
  1761.  
  1762.   ArrayRef<Binding> bindings() const {
  1763.     return llvm::ArrayRef(Bindings, NumBindings);
  1764.   }
  1765.  
  1766.   bool isSet() const { return LSquareLoc.isValid(); }
  1767.  
  1768.   SourceLocation getLSquareLoc() const { return LSquareLoc; }
  1769.   SourceLocation getRSquareLoc() const { return RSquareLoc; }
  1770.   SourceRange getSourceRange() const {
  1771.     return SourceRange(LSquareLoc, RSquareLoc);
  1772.   }
  1773. };
  1774.  
  1775. /// Described the kind of function definition (if any) provided for
  1776. /// a function.
  1777. enum class FunctionDefinitionKind {
  1778.   Declaration,
  1779.   Definition,
  1780.   Defaulted,
  1781.   Deleted
  1782. };
  1783.  
  1784. enum class DeclaratorContext {
  1785.   File,                // File scope declaration.
  1786.   Prototype,           // Within a function prototype.
  1787.   ObjCResult,          // An ObjC method result type.
  1788.   ObjCParameter,       // An ObjC method parameter type.
  1789.   KNRTypeList,         // K&R type definition list for formals.
  1790.   TypeName,            // Abstract declarator for types.
  1791.   FunctionalCast,      // Type in a C++ functional cast expression.
  1792.   Member,              // Struct/Union field.
  1793.   Block,               // Declaration within a block in a function.
  1794.   ForInit,             // Declaration within first part of a for loop.
  1795.   SelectionInit,       // Declaration within optional init stmt of if/switch.
  1796.   Condition,           // Condition declaration in a C++ if/switch/while/for.
  1797.   TemplateParam,       // Within a template parameter list.
  1798.   CXXNew,              // C++ new-expression.
  1799.   CXXCatch,            // C++ catch exception-declaration
  1800.   ObjCCatch,           // Objective-C catch exception-declaration
  1801.   BlockLiteral,        // Block literal declarator.
  1802.   LambdaExpr,          // Lambda-expression declarator.
  1803.   LambdaExprParameter, // Lambda-expression parameter declarator.
  1804.   ConversionId,        // C++ conversion-type-id.
  1805.   TrailingReturn,      // C++11 trailing-type-specifier.
  1806.   TrailingReturnVar,   // C++11 trailing-type-specifier for variable.
  1807.   TemplateArg,         // Any template argument (in template argument list).
  1808.   TemplateTypeArg,     // Template type argument (in default argument).
  1809.   AliasDecl,           // C++11 alias-declaration.
  1810.   AliasTemplate,       // C++11 alias-declaration template.
  1811.   RequiresExpr,        // C++2a requires-expression.
  1812.   Association          // C11 _Generic selection expression association.
  1813. };
  1814.  
  1815. // Describes whether the current context is a context where an implicit
  1816. // typename is allowed (C++2a [temp.res]p5]).
  1817. enum class ImplicitTypenameContext {
  1818.   No,
  1819.   Yes,
  1820. };
  1821.  
  1822. /// Information about one declarator, including the parsed type
  1823. /// information and the identifier.
  1824. ///
  1825. /// When the declarator is fully formed, this is turned into the appropriate
  1826. /// Decl object.
  1827. ///
  1828. /// Declarators come in two types: normal declarators and abstract declarators.
  1829. /// Abstract declarators are used when parsing types, and don't have an
  1830. /// identifier.  Normal declarators do have ID's.
  1831. ///
  1832. /// Instances of this class should be a transient object that lives on the
  1833. /// stack, not objects that are allocated in large quantities on the heap.
  1834. class Declarator {
  1835.  
  1836. private:
  1837.   const DeclSpec &DS;
  1838.   CXXScopeSpec SS;
  1839.   UnqualifiedId Name;
  1840.   SourceRange Range;
  1841.  
  1842.   /// Where we are parsing this declarator.
  1843.   DeclaratorContext Context;
  1844.  
  1845.   /// The C++17 structured binding, if any. This is an alternative to a Name.
  1846.   DecompositionDeclarator BindingGroup;
  1847.  
  1848.   /// DeclTypeInfo - This holds each type that the declarator includes as it is
  1849.   /// parsed.  This is pushed from the identifier out, which means that element
  1850.   /// #0 will be the most closely bound to the identifier, and
  1851.   /// DeclTypeInfo.back() will be the least closely bound.
  1852.   SmallVector<DeclaratorChunk, 8> DeclTypeInfo;
  1853.  
  1854.   /// InvalidType - Set by Sema::GetTypeForDeclarator().
  1855.   unsigned InvalidType : 1;
  1856.  
  1857.   /// GroupingParens - Set by Parser::ParseParenDeclarator().
  1858.   unsigned GroupingParens : 1;
  1859.  
  1860.   /// FunctionDefinition - Is this Declarator for a function or member
  1861.   /// definition and, if so, what kind?
  1862.   ///
  1863.   /// Actually a FunctionDefinitionKind.
  1864.   unsigned FunctionDefinition : 2;
  1865.  
  1866.   /// Is this Declarator a redeclaration?
  1867.   unsigned Redeclaration : 1;
  1868.  
  1869.   /// true if the declaration is preceded by \c __extension__.
  1870.   unsigned Extension : 1;
  1871.  
  1872.   /// Indicates whether this is an Objective-C instance variable.
  1873.   unsigned ObjCIvar : 1;
  1874.  
  1875.   /// Indicates whether this is an Objective-C 'weak' property.
  1876.   unsigned ObjCWeakProperty : 1;
  1877.  
  1878.   /// Indicates whether the InlineParams / InlineBindings storage has been used.
  1879.   unsigned InlineStorageUsed : 1;
  1880.  
  1881.   /// Indicates whether this declarator has an initializer.
  1882.   unsigned HasInitializer : 1;
  1883.  
  1884.   /// Attributes attached to the declarator.
  1885.   ParsedAttributes Attrs;
  1886.  
  1887.   /// Attributes attached to the declaration. See also documentation for the
  1888.   /// corresponding constructor parameter.
  1889.   const ParsedAttributesView &DeclarationAttrs;
  1890.  
  1891.   /// The asm label, if specified.
  1892.   Expr *AsmLabel;
  1893.  
  1894.   /// \brief The constraint-expression specified by the trailing
  1895.   /// requires-clause, or null if no such clause was specified.
  1896.   Expr *TrailingRequiresClause;
  1897.  
  1898.   /// If this declarator declares a template, its template parameter lists.
  1899.   ArrayRef<TemplateParameterList *> TemplateParameterLists;
  1900.  
  1901.   /// If the declarator declares an abbreviated function template, the innermost
  1902.   /// template parameter list containing the invented and explicit template
  1903.   /// parameters (if any).
  1904.   TemplateParameterList *InventedTemplateParameterList;
  1905.  
  1906. #ifndef _MSC_VER
  1907.   union {
  1908. #endif
  1909.     /// InlineParams - This is a local array used for the first function decl
  1910.     /// chunk to avoid going to the heap for the common case when we have one
  1911.     /// function chunk in the declarator.
  1912.     DeclaratorChunk::ParamInfo InlineParams[16];
  1913.     DecompositionDeclarator::Binding InlineBindings[16];
  1914. #ifndef _MSC_VER
  1915.   };
  1916. #endif
  1917.  
  1918.   /// If this is the second or subsequent declarator in this declaration,
  1919.   /// the location of the comma before this declarator.
  1920.   SourceLocation CommaLoc;
  1921.  
  1922.   /// If provided, the source location of the ellipsis used to describe
  1923.   /// this declarator as a parameter pack.
  1924.   SourceLocation EllipsisLoc;
  1925.  
  1926.   friend struct DeclaratorChunk;
  1927.  
  1928. public:
  1929.   /// `DS` and `DeclarationAttrs` must outlive the `Declarator`. In particular,
  1930.   /// take care not to pass temporary objects for these parameters.
  1931.   ///
  1932.   /// `DeclarationAttrs` contains [[]] attributes from the
  1933.   /// attribute-specifier-seq at the beginning of a declaration, which appertain
  1934.   /// to the declared entity itself. Attributes with other syntax (e.g. GNU)
  1935.   /// should not be placed in this attribute list; if they occur at the
  1936.   /// beginning of a declaration, they apply to the `DeclSpec` and should be
  1937.   /// attached to that instead.
  1938.   ///
  1939.   /// Here is an example of an attribute associated with a declaration:
  1940.   ///
  1941.   ///  [[deprecated]] int x, y;
  1942.   ///
  1943.   /// This attribute appertains to all of the entities declared in the
  1944.   /// declaration, i.e. `x` and `y` in this case.
  1945.   Declarator(const DeclSpec &DS, const ParsedAttributesView &DeclarationAttrs,
  1946.              DeclaratorContext C)
  1947.       : DS(DS), Range(DS.getSourceRange()), Context(C),
  1948.         InvalidType(DS.getTypeSpecType() == DeclSpec::TST_error),
  1949.         GroupingParens(false), FunctionDefinition(static_cast<unsigned>(
  1950.                                    FunctionDefinitionKind::Declaration)),
  1951.         Redeclaration(false), Extension(false), ObjCIvar(false),
  1952.         ObjCWeakProperty(false), InlineStorageUsed(false),
  1953.         HasInitializer(false), Attrs(DS.getAttributePool().getFactory()),
  1954.         DeclarationAttrs(DeclarationAttrs), AsmLabel(nullptr),
  1955.         TrailingRequiresClause(nullptr),
  1956.         InventedTemplateParameterList(nullptr) {
  1957.     assert(llvm::all_of(DeclarationAttrs,
  1958.                         [](const ParsedAttr &AL) {
  1959.                           return AL.isStandardAttributeSyntax();
  1960.                         }) &&
  1961.            "DeclarationAttrs may only contain [[]] attributes");
  1962.   }
  1963.  
  1964.   ~Declarator() {
  1965.     clear();
  1966.   }
  1967.   /// getDeclSpec - Return the declaration-specifier that this declarator was
  1968.   /// declared with.
  1969.   const DeclSpec &getDeclSpec() const { return DS; }
  1970.  
  1971.   /// getMutableDeclSpec - Return a non-const version of the DeclSpec.  This
  1972.   /// should be used with extreme care: declspecs can often be shared between
  1973.   /// multiple declarators, so mutating the DeclSpec affects all of the
  1974.   /// Declarators.  This should only be done when the declspec is known to not
  1975.   /// be shared or when in error recovery etc.
  1976.   DeclSpec &getMutableDeclSpec() { return const_cast<DeclSpec &>(DS); }
  1977.  
  1978.   AttributePool &getAttributePool() const {
  1979.     return Attrs.getPool();
  1980.   }
  1981.  
  1982.   /// getCXXScopeSpec - Return the C++ scope specifier (global scope or
  1983.   /// nested-name-specifier) that is part of the declarator-id.
  1984.   const CXXScopeSpec &getCXXScopeSpec() const { return SS; }
  1985.   CXXScopeSpec &getCXXScopeSpec() { return SS; }
  1986.  
  1987.   /// Retrieve the name specified by this declarator.
  1988.   UnqualifiedId &getName() { return Name; }
  1989.  
  1990.   const DecompositionDeclarator &getDecompositionDeclarator() const {
  1991.     return BindingGroup;
  1992.   }
  1993.  
  1994.   DeclaratorContext getContext() const { return Context; }
  1995.  
  1996.   bool isPrototypeContext() const {
  1997.     return (Context == DeclaratorContext::Prototype ||
  1998.             Context == DeclaratorContext::ObjCParameter ||
  1999.             Context == DeclaratorContext::ObjCResult ||
  2000.             Context == DeclaratorContext::LambdaExprParameter);
  2001.   }
  2002.  
  2003.   /// Get the source range that spans this declarator.
  2004.   SourceRange getSourceRange() const LLVM_READONLY { return Range; }
  2005.   SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }
  2006.   SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }
  2007.  
  2008.   void SetSourceRange(SourceRange R) { Range = R; }
  2009.   /// SetRangeBegin - Set the start of the source range to Loc, unless it's
  2010.   /// invalid.
  2011.   void SetRangeBegin(SourceLocation Loc) {
  2012.     if (!Loc.isInvalid())
  2013.       Range.setBegin(Loc);
  2014.   }
  2015.   /// SetRangeEnd - Set the end of the source range to Loc, unless it's invalid.
  2016.   void SetRangeEnd(SourceLocation Loc) {
  2017.     if (!Loc.isInvalid())
  2018.       Range.setEnd(Loc);
  2019.   }
  2020.   /// ExtendWithDeclSpec - Extend the declarator source range to include the
  2021.   /// given declspec, unless its location is invalid. Adopts the range start if
  2022.   /// the current range start is invalid.
  2023.   void ExtendWithDeclSpec(const DeclSpec &DS) {
  2024.     SourceRange SR = DS.getSourceRange();
  2025.     if (Range.getBegin().isInvalid())
  2026.       Range.setBegin(SR.getBegin());
  2027.     if (!SR.getEnd().isInvalid())
  2028.       Range.setEnd(SR.getEnd());
  2029.   }
  2030.  
  2031.   /// Reset the contents of this Declarator.
  2032.   void clear() {
  2033.     SS.clear();
  2034.     Name.clear();
  2035.     Range = DS.getSourceRange();
  2036.     BindingGroup.clear();
  2037.  
  2038.     for (unsigned i = 0, e = DeclTypeInfo.size(); i != e; ++i)
  2039.       DeclTypeInfo[i].destroy();
  2040.     DeclTypeInfo.clear();
  2041.     Attrs.clear();
  2042.     AsmLabel = nullptr;
  2043.     InlineStorageUsed = false;
  2044.     HasInitializer = false;
  2045.     ObjCIvar = false;
  2046.     ObjCWeakProperty = false;
  2047.     CommaLoc = SourceLocation();
  2048.     EllipsisLoc = SourceLocation();
  2049.   }
  2050.  
  2051.   /// mayOmitIdentifier - Return true if the identifier is either optional or
  2052.   /// not allowed.  This is true for typenames, prototypes, and template
  2053.   /// parameter lists.
  2054.   bool mayOmitIdentifier() const {
  2055.     switch (Context) {
  2056.     case DeclaratorContext::File:
  2057.     case DeclaratorContext::KNRTypeList:
  2058.     case DeclaratorContext::Member:
  2059.     case DeclaratorContext::Block:
  2060.     case DeclaratorContext::ForInit:
  2061.     case DeclaratorContext::SelectionInit:
  2062.     case DeclaratorContext::Condition:
  2063.       return false;
  2064.  
  2065.     case DeclaratorContext::TypeName:
  2066.     case DeclaratorContext::FunctionalCast:
  2067.     case DeclaratorContext::AliasDecl:
  2068.     case DeclaratorContext::AliasTemplate:
  2069.     case DeclaratorContext::Prototype:
  2070.     case DeclaratorContext::LambdaExprParameter:
  2071.     case DeclaratorContext::ObjCParameter:
  2072.     case DeclaratorContext::ObjCResult:
  2073.     case DeclaratorContext::TemplateParam:
  2074.     case DeclaratorContext::CXXNew:
  2075.     case DeclaratorContext::CXXCatch:
  2076.     case DeclaratorContext::ObjCCatch:
  2077.     case DeclaratorContext::BlockLiteral:
  2078.     case DeclaratorContext::LambdaExpr:
  2079.     case DeclaratorContext::ConversionId:
  2080.     case DeclaratorContext::TemplateArg:
  2081.     case DeclaratorContext::TemplateTypeArg:
  2082.     case DeclaratorContext::TrailingReturn:
  2083.     case DeclaratorContext::TrailingReturnVar:
  2084.     case DeclaratorContext::RequiresExpr:
  2085.     case DeclaratorContext::Association:
  2086.       return true;
  2087.     }
  2088.     llvm_unreachable("unknown context kind!");
  2089.   }
  2090.  
  2091.   /// mayHaveIdentifier - Return true if the identifier is either optional or
  2092.   /// required.  This is true for normal declarators and prototypes, but not
  2093.   /// typenames.
  2094.   bool mayHaveIdentifier() const {
  2095.     switch (Context) {
  2096.     case DeclaratorContext::File:
  2097.     case DeclaratorContext::KNRTypeList:
  2098.     case DeclaratorContext::Member:
  2099.     case DeclaratorContext::Block:
  2100.     case DeclaratorContext::ForInit:
  2101.     case DeclaratorContext::SelectionInit:
  2102.     case DeclaratorContext::Condition:
  2103.     case DeclaratorContext::Prototype:
  2104.     case DeclaratorContext::LambdaExprParameter:
  2105.     case DeclaratorContext::TemplateParam:
  2106.     case DeclaratorContext::CXXCatch:
  2107.     case DeclaratorContext::ObjCCatch:
  2108.     case DeclaratorContext::RequiresExpr:
  2109.       return true;
  2110.  
  2111.     case DeclaratorContext::TypeName:
  2112.     case DeclaratorContext::FunctionalCast:
  2113.     case DeclaratorContext::CXXNew:
  2114.     case DeclaratorContext::AliasDecl:
  2115.     case DeclaratorContext::AliasTemplate:
  2116.     case DeclaratorContext::ObjCParameter:
  2117.     case DeclaratorContext::ObjCResult:
  2118.     case DeclaratorContext::BlockLiteral:
  2119.     case DeclaratorContext::LambdaExpr:
  2120.     case DeclaratorContext::ConversionId:
  2121.     case DeclaratorContext::TemplateArg:
  2122.     case DeclaratorContext::TemplateTypeArg:
  2123.     case DeclaratorContext::TrailingReturn:
  2124.     case DeclaratorContext::TrailingReturnVar:
  2125.     case DeclaratorContext::Association:
  2126.       return false;
  2127.     }
  2128.     llvm_unreachable("unknown context kind!");
  2129.   }
  2130.  
  2131.   /// Return true if the context permits a C++17 decomposition declarator.
  2132.   bool mayHaveDecompositionDeclarator() const {
  2133.     switch (Context) {
  2134.     case DeclaratorContext::File:
  2135.       // FIXME: It's not clear that the proposal meant to allow file-scope
  2136.       // structured bindings, but it does.
  2137.     case DeclaratorContext::Block:
  2138.     case DeclaratorContext::ForInit:
  2139.     case DeclaratorContext::SelectionInit:
  2140.     case DeclaratorContext::Condition:
  2141.       return true;
  2142.  
  2143.     case DeclaratorContext::Member:
  2144.     case DeclaratorContext::Prototype:
  2145.     case DeclaratorContext::TemplateParam:
  2146.     case DeclaratorContext::RequiresExpr:
  2147.       // Maybe one day...
  2148.       return false;
  2149.  
  2150.     // These contexts don't allow any kind of non-abstract declarator.
  2151.     case DeclaratorContext::KNRTypeList:
  2152.     case DeclaratorContext::TypeName:
  2153.     case DeclaratorContext::FunctionalCast:
  2154.     case DeclaratorContext::AliasDecl:
  2155.     case DeclaratorContext::AliasTemplate:
  2156.     case DeclaratorContext::LambdaExprParameter:
  2157.     case DeclaratorContext::ObjCParameter:
  2158.     case DeclaratorContext::ObjCResult:
  2159.     case DeclaratorContext::CXXNew:
  2160.     case DeclaratorContext::CXXCatch:
  2161.     case DeclaratorContext::ObjCCatch:
  2162.     case DeclaratorContext::BlockLiteral:
  2163.     case DeclaratorContext::LambdaExpr:
  2164.     case DeclaratorContext::ConversionId:
  2165.     case DeclaratorContext::TemplateArg:
  2166.     case DeclaratorContext::TemplateTypeArg:
  2167.     case DeclaratorContext::TrailingReturn:
  2168.     case DeclaratorContext::TrailingReturnVar:
  2169.     case DeclaratorContext::Association:
  2170.       return false;
  2171.     }
  2172.     llvm_unreachable("unknown context kind!");
  2173.   }
  2174.  
  2175.   /// mayBeFollowedByCXXDirectInit - Return true if the declarator can be
  2176.   /// followed by a C++ direct initializer, e.g. "int x(1);".
  2177.   bool mayBeFollowedByCXXDirectInit() const {
  2178.     if (hasGroupingParens()) return false;
  2179.  
  2180.     if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
  2181.       return false;
  2182.  
  2183.     if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern &&
  2184.         Context != DeclaratorContext::File)
  2185.       return false;
  2186.  
  2187.     // Special names can't have direct initializers.
  2188.     if (Name.getKind() != UnqualifiedIdKind::IK_Identifier)
  2189.       return false;
  2190.  
  2191.     switch (Context) {
  2192.     case DeclaratorContext::File:
  2193.     case DeclaratorContext::Block:
  2194.     case DeclaratorContext::ForInit:
  2195.     case DeclaratorContext::SelectionInit:
  2196.     case DeclaratorContext::TrailingReturnVar:
  2197.       return true;
  2198.  
  2199.     case DeclaratorContext::Condition:
  2200.       // This may not be followed by a direct initializer, but it can't be a
  2201.       // function declaration either, and we'd prefer to perform a tentative
  2202.       // parse in order to produce the right diagnostic.
  2203.       return true;
  2204.  
  2205.     case DeclaratorContext::KNRTypeList:
  2206.     case DeclaratorContext::Member:
  2207.     case DeclaratorContext::Prototype:
  2208.     case DeclaratorContext::LambdaExprParameter:
  2209.     case DeclaratorContext::ObjCParameter:
  2210.     case DeclaratorContext::ObjCResult:
  2211.     case DeclaratorContext::TemplateParam:
  2212.     case DeclaratorContext::CXXCatch:
  2213.     case DeclaratorContext::ObjCCatch:
  2214.     case DeclaratorContext::TypeName:
  2215.     case DeclaratorContext::FunctionalCast: // FIXME
  2216.     case DeclaratorContext::CXXNew:
  2217.     case DeclaratorContext::AliasDecl:
  2218.     case DeclaratorContext::AliasTemplate:
  2219.     case DeclaratorContext::BlockLiteral:
  2220.     case DeclaratorContext::LambdaExpr:
  2221.     case DeclaratorContext::ConversionId:
  2222.     case DeclaratorContext::TemplateArg:
  2223.     case DeclaratorContext::TemplateTypeArg:
  2224.     case DeclaratorContext::TrailingReturn:
  2225.     case DeclaratorContext::RequiresExpr:
  2226.     case DeclaratorContext::Association:
  2227.       return false;
  2228.     }
  2229.     llvm_unreachable("unknown context kind!");
  2230.   }
  2231.  
  2232.   /// isPastIdentifier - Return true if we have parsed beyond the point where
  2233.   /// the name would appear. (This may happen even if we haven't actually parsed
  2234.   /// a name, perhaps because this context doesn't require one.)
  2235.   bool isPastIdentifier() const { return Name.isValid(); }
  2236.  
  2237.   /// hasName - Whether this declarator has a name, which might be an
  2238.   /// identifier (accessible via getIdentifier()) or some kind of
  2239.   /// special C++ name (constructor, destructor, etc.), or a structured
  2240.   /// binding (which is not exactly a name, but occupies the same position).
  2241.   bool hasName() const {
  2242.     return Name.getKind() != UnqualifiedIdKind::IK_Identifier ||
  2243.            Name.Identifier || isDecompositionDeclarator();
  2244.   }
  2245.  
  2246.   /// Return whether this declarator is a decomposition declarator.
  2247.   bool isDecompositionDeclarator() const {
  2248.     return BindingGroup.isSet();
  2249.   }
  2250.  
  2251.   IdentifierInfo *getIdentifier() const {
  2252.     if (Name.getKind() == UnqualifiedIdKind::IK_Identifier)
  2253.       return Name.Identifier;
  2254.  
  2255.     return nullptr;
  2256.   }
  2257.   SourceLocation getIdentifierLoc() const { return Name.StartLocation; }
  2258.  
  2259.   /// Set the name of this declarator to be the given identifier.
  2260.   void SetIdentifier(IdentifierInfo *Id, SourceLocation IdLoc) {
  2261.     Name.setIdentifier(Id, IdLoc);
  2262.   }
  2263.  
  2264.   /// Set the decomposition bindings for this declarator.
  2265.   void
  2266.   setDecompositionBindings(SourceLocation LSquareLoc,
  2267.                            ArrayRef<DecompositionDeclarator::Binding> Bindings,
  2268.                            SourceLocation RSquareLoc);
  2269.  
  2270.   /// AddTypeInfo - Add a chunk to this declarator. Also extend the range to
  2271.   /// EndLoc, which should be the last token of the chunk.
  2272.   /// This function takes attrs by R-Value reference because it takes ownership
  2273.   /// of those attributes from the parameter.
  2274.   void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &&attrs,
  2275.                    SourceLocation EndLoc) {
  2276.     DeclTypeInfo.push_back(TI);
  2277.     DeclTypeInfo.back().getAttrs().addAll(attrs.begin(), attrs.end());
  2278.     getAttributePool().takeAllFrom(attrs.getPool());
  2279.  
  2280.     if (!EndLoc.isInvalid())
  2281.       SetRangeEnd(EndLoc);
  2282.   }
  2283.  
  2284.   /// AddTypeInfo - Add a chunk to this declarator. Also extend the range to
  2285.   /// EndLoc, which should be the last token of the chunk.
  2286.   void AddTypeInfo(const DeclaratorChunk &TI, SourceLocation EndLoc) {
  2287.     DeclTypeInfo.push_back(TI);
  2288.  
  2289.     if (!EndLoc.isInvalid())
  2290.       SetRangeEnd(EndLoc);
  2291.   }
  2292.  
  2293.   /// Add a new innermost chunk to this declarator.
  2294.   void AddInnermostTypeInfo(const DeclaratorChunk &TI) {
  2295.     DeclTypeInfo.insert(DeclTypeInfo.begin(), TI);
  2296.   }
  2297.  
  2298.   /// Return the number of types applied to this declarator.
  2299.   unsigned getNumTypeObjects() const { return DeclTypeInfo.size(); }
  2300.  
  2301.   /// Return the specified TypeInfo from this declarator.  TypeInfo #0 is
  2302.   /// closest to the identifier.
  2303.   const DeclaratorChunk &getTypeObject(unsigned i) const {
  2304.     assert(i < DeclTypeInfo.size() && "Invalid type chunk");
  2305.     return DeclTypeInfo[i];
  2306.   }
  2307.   DeclaratorChunk &getTypeObject(unsigned i) {
  2308.     assert(i < DeclTypeInfo.size() && "Invalid type chunk");
  2309.     return DeclTypeInfo[i];
  2310.   }
  2311.  
  2312.   typedef SmallVectorImpl<DeclaratorChunk>::const_iterator type_object_iterator;
  2313.   typedef llvm::iterator_range<type_object_iterator> type_object_range;
  2314.  
  2315.   /// Returns the range of type objects, from the identifier outwards.
  2316.   type_object_range type_objects() const {
  2317.     return type_object_range(DeclTypeInfo.begin(), DeclTypeInfo.end());
  2318.   }
  2319.  
  2320.   void DropFirstTypeObject() {
  2321.     assert(!DeclTypeInfo.empty() && "No type chunks to drop.");
  2322.     DeclTypeInfo.front().destroy();
  2323.     DeclTypeInfo.erase(DeclTypeInfo.begin());
  2324.   }
  2325.  
  2326.   /// Return the innermost (closest to the declarator) chunk of this
  2327.   /// declarator that is not a parens chunk, or null if there are no
  2328.   /// non-parens chunks.
  2329.   const DeclaratorChunk *getInnermostNonParenChunk() const {
  2330.     for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
  2331.       if (!DeclTypeInfo[i].isParen())
  2332.         return &DeclTypeInfo[i];
  2333.     }
  2334.     return nullptr;
  2335.   }
  2336.  
  2337.   /// Return the outermost (furthest from the declarator) chunk of
  2338.   /// this declarator that is not a parens chunk, or null if there are
  2339.   /// no non-parens chunks.
  2340.   const DeclaratorChunk *getOutermostNonParenChunk() const {
  2341.     for (unsigned i = DeclTypeInfo.size(), i_end = 0; i != i_end; --i) {
  2342.       if (!DeclTypeInfo[i-1].isParen())
  2343.         return &DeclTypeInfo[i-1];
  2344.     }
  2345.     return nullptr;
  2346.   }
  2347.  
  2348.   /// isArrayOfUnknownBound - This method returns true if the declarator
  2349.   /// is a declarator for an array of unknown bound (looking through
  2350.   /// parentheses).
  2351.   bool isArrayOfUnknownBound() const {
  2352.     const DeclaratorChunk *chunk = getInnermostNonParenChunk();
  2353.     return (chunk && chunk->Kind == DeclaratorChunk::Array &&
  2354.             !chunk->Arr.NumElts);
  2355.   }
  2356.  
  2357.   /// isFunctionDeclarator - This method returns true if the declarator
  2358.   /// is a function declarator (looking through parentheses).
  2359.   /// If true is returned, then the reference type parameter idx is
  2360.   /// assigned with the index of the declaration chunk.
  2361.   bool isFunctionDeclarator(unsigned& idx) const {
  2362.     for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
  2363.       switch (DeclTypeInfo[i].Kind) {
  2364.       case DeclaratorChunk::Function:
  2365.         idx = i;
  2366.         return true;
  2367.       case DeclaratorChunk::Paren:
  2368.         continue;
  2369.       case DeclaratorChunk::Pointer:
  2370.       case DeclaratorChunk::Reference:
  2371.       case DeclaratorChunk::Array:
  2372.       case DeclaratorChunk::BlockPointer:
  2373.       case DeclaratorChunk::MemberPointer:
  2374.       case DeclaratorChunk::Pipe:
  2375.         return false;
  2376.       }
  2377.       llvm_unreachable("Invalid type chunk");
  2378.     }
  2379.     return false;
  2380.   }
  2381.  
  2382.   /// isFunctionDeclarator - Once this declarator is fully parsed and formed,
  2383.   /// this method returns true if the identifier is a function declarator
  2384.   /// (looking through parentheses).
  2385.   bool isFunctionDeclarator() const {
  2386.     unsigned index;
  2387.     return isFunctionDeclarator(index);
  2388.   }
  2389.  
  2390.   /// getFunctionTypeInfo - Retrieves the function type info object
  2391.   /// (looking through parentheses).
  2392.   DeclaratorChunk::FunctionTypeInfo &getFunctionTypeInfo() {
  2393.     assert(isFunctionDeclarator() && "Not a function declarator!");
  2394.     unsigned index = 0;
  2395.     isFunctionDeclarator(index);
  2396.     return DeclTypeInfo[index].Fun;
  2397.   }
  2398.  
  2399.   /// getFunctionTypeInfo - Retrieves the function type info object
  2400.   /// (looking through parentheses).
  2401.   const DeclaratorChunk::FunctionTypeInfo &getFunctionTypeInfo() const {
  2402.     return const_cast<Declarator*>(this)->getFunctionTypeInfo();
  2403.   }
  2404.  
  2405.   /// Determine whether the declaration that will be produced from
  2406.   /// this declaration will be a function.
  2407.   ///
  2408.   /// A declaration can declare a function even if the declarator itself
  2409.   /// isn't a function declarator, if the type specifier refers to a function
  2410.   /// type. This routine checks for both cases.
  2411.   bool isDeclarationOfFunction() const;
  2412.  
  2413.   /// Return true if this declaration appears in a context where a
  2414.   /// function declarator would be a function declaration.
  2415.   bool isFunctionDeclarationContext() const {
  2416.     if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
  2417.       return false;
  2418.  
  2419.     switch (Context) {
  2420.     case DeclaratorContext::File:
  2421.     case DeclaratorContext::Member:
  2422.     case DeclaratorContext::Block:
  2423.     case DeclaratorContext::ForInit:
  2424.     case DeclaratorContext::SelectionInit:
  2425.       return true;
  2426.  
  2427.     case DeclaratorContext::Condition:
  2428.     case DeclaratorContext::KNRTypeList:
  2429.     case DeclaratorContext::TypeName:
  2430.     case DeclaratorContext::FunctionalCast:
  2431.     case DeclaratorContext::AliasDecl:
  2432.     case DeclaratorContext::AliasTemplate:
  2433.     case DeclaratorContext::Prototype:
  2434.     case DeclaratorContext::LambdaExprParameter:
  2435.     case DeclaratorContext::ObjCParameter:
  2436.     case DeclaratorContext::ObjCResult:
  2437.     case DeclaratorContext::TemplateParam:
  2438.     case DeclaratorContext::CXXNew:
  2439.     case DeclaratorContext::CXXCatch:
  2440.     case DeclaratorContext::ObjCCatch:
  2441.     case DeclaratorContext::BlockLiteral:
  2442.     case DeclaratorContext::LambdaExpr:
  2443.     case DeclaratorContext::ConversionId:
  2444.     case DeclaratorContext::TemplateArg:
  2445.     case DeclaratorContext::TemplateTypeArg:
  2446.     case DeclaratorContext::TrailingReturn:
  2447.     case DeclaratorContext::TrailingReturnVar:
  2448.     case DeclaratorContext::RequiresExpr:
  2449.     case DeclaratorContext::Association:
  2450.       return false;
  2451.     }
  2452.     llvm_unreachable("unknown context kind!");
  2453.   }
  2454.  
  2455.   /// Determine whether this declaration appears in a context where an
  2456.   /// expression could appear.
  2457.   bool isExpressionContext() const {
  2458.     switch (Context) {
  2459.     case DeclaratorContext::File:
  2460.     case DeclaratorContext::KNRTypeList:
  2461.     case DeclaratorContext::Member:
  2462.  
  2463.     // FIXME: sizeof(...) permits an expression.
  2464.     case DeclaratorContext::TypeName:
  2465.  
  2466.     case DeclaratorContext::FunctionalCast:
  2467.     case DeclaratorContext::AliasDecl:
  2468.     case DeclaratorContext::AliasTemplate:
  2469.     case DeclaratorContext::Prototype:
  2470.     case DeclaratorContext::LambdaExprParameter:
  2471.     case DeclaratorContext::ObjCParameter:
  2472.     case DeclaratorContext::ObjCResult:
  2473.     case DeclaratorContext::TemplateParam:
  2474.     case DeclaratorContext::CXXNew:
  2475.     case DeclaratorContext::CXXCatch:
  2476.     case DeclaratorContext::ObjCCatch:
  2477.     case DeclaratorContext::BlockLiteral:
  2478.     case DeclaratorContext::LambdaExpr:
  2479.     case DeclaratorContext::ConversionId:
  2480.     case DeclaratorContext::TrailingReturn:
  2481.     case DeclaratorContext::TrailingReturnVar:
  2482.     case DeclaratorContext::TemplateTypeArg:
  2483.     case DeclaratorContext::RequiresExpr:
  2484.     case DeclaratorContext::Association:
  2485.       return false;
  2486.  
  2487.     case DeclaratorContext::Block:
  2488.     case DeclaratorContext::ForInit:
  2489.     case DeclaratorContext::SelectionInit:
  2490.     case DeclaratorContext::Condition:
  2491.     case DeclaratorContext::TemplateArg:
  2492.       return true;
  2493.     }
  2494.  
  2495.     llvm_unreachable("unknown context kind!");
  2496.   }
  2497.  
  2498.   /// Return true if a function declarator at this position would be a
  2499.   /// function declaration.
  2500.   bool isFunctionDeclaratorAFunctionDeclaration() const {
  2501.     if (!isFunctionDeclarationContext())
  2502.       return false;
  2503.  
  2504.     for (unsigned I = 0, N = getNumTypeObjects(); I != N; ++I)
  2505.       if (getTypeObject(I).Kind != DeclaratorChunk::Paren)
  2506.         return false;
  2507.  
  2508.     return true;
  2509.   }
  2510.  
  2511.   /// Determine whether a trailing return type was written (at any
  2512.   /// level) within this declarator.
  2513.   bool hasTrailingReturnType() const {
  2514.     for (const auto &Chunk : type_objects())
  2515.       if (Chunk.Kind == DeclaratorChunk::Function &&
  2516.           Chunk.Fun.hasTrailingReturnType())
  2517.         return true;
  2518.     return false;
  2519.   }
  2520.   /// Get the trailing return type appearing (at any level) within this
  2521.   /// declarator.
  2522.   ParsedType getTrailingReturnType() const {
  2523.     for (const auto &Chunk : type_objects())
  2524.       if (Chunk.Kind == DeclaratorChunk::Function &&
  2525.           Chunk.Fun.hasTrailingReturnType())
  2526.         return Chunk.Fun.getTrailingReturnType();
  2527.     return ParsedType();
  2528.   }
  2529.  
  2530.   /// \brief Sets a trailing requires clause for this declarator.
  2531.   void setTrailingRequiresClause(Expr *TRC) {
  2532.     TrailingRequiresClause = TRC;
  2533.  
  2534.     SetRangeEnd(TRC->getEndLoc());
  2535.   }
  2536.  
  2537.   /// \brief Sets a trailing requires clause for this declarator.
  2538.   Expr *getTrailingRequiresClause() {
  2539.     return TrailingRequiresClause;
  2540.   }
  2541.  
  2542.   /// \brief Determine whether a trailing requires clause was written in this
  2543.   /// declarator.
  2544.   bool hasTrailingRequiresClause() const {
  2545.     return TrailingRequiresClause != nullptr;
  2546.   }
  2547.  
  2548.   /// Sets the template parameter lists that preceded the declarator.
  2549.   void setTemplateParameterLists(ArrayRef<TemplateParameterList *> TPLs) {
  2550.     TemplateParameterLists = TPLs;
  2551.   }
  2552.  
  2553.   /// The template parameter lists that preceded the declarator.
  2554.   ArrayRef<TemplateParameterList *> getTemplateParameterLists() const {
  2555.     return TemplateParameterLists;
  2556.   }
  2557.  
  2558.   /// Sets the template parameter list generated from the explicit template
  2559.   /// parameters along with any invented template parameters from
  2560.   /// placeholder-typed parameters.
  2561.   void setInventedTemplateParameterList(TemplateParameterList *Invented) {
  2562.     InventedTemplateParameterList = Invented;
  2563.   }
  2564.  
  2565.   /// The template parameter list generated from the explicit template
  2566.   /// parameters along with any invented template parameters from
  2567.   /// placeholder-typed parameters, if there were any such parameters.
  2568.   TemplateParameterList * getInventedTemplateParameterList() const {
  2569.     return InventedTemplateParameterList;
  2570.   }
  2571.  
  2572.   /// takeAttributes - Takes attributes from the given parsed-attributes
  2573.   /// set and add them to this declarator.
  2574.   ///
  2575.   /// These examples both add 3 attributes to "var":
  2576.   ///  short int var __attribute__((aligned(16),common,deprecated));
  2577.   ///  short int x, __attribute__((aligned(16)) var
  2578.   ///                                 __attribute__((common,deprecated));
  2579.   ///
  2580.   /// Also extends the range of the declarator.
  2581.   void takeAttributes(ParsedAttributes &attrs) {
  2582.     Attrs.takeAllFrom(attrs);
  2583.  
  2584.     if (attrs.Range.getEnd().isValid())
  2585.       SetRangeEnd(attrs.Range.getEnd());
  2586.   }
  2587.  
  2588.   const ParsedAttributes &getAttributes() const { return Attrs; }
  2589.   ParsedAttributes &getAttributes() { return Attrs; }
  2590.  
  2591.   const ParsedAttributesView &getDeclarationAttributes() const {
  2592.     return DeclarationAttrs;
  2593.   }
  2594.  
  2595.   /// hasAttributes - do we contain any attributes?
  2596.   bool hasAttributes() const {
  2597.     if (!getAttributes().empty() || !getDeclarationAttributes().empty() ||
  2598.         getDeclSpec().hasAttributes())
  2599.       return true;
  2600.     for (unsigned i = 0, e = getNumTypeObjects(); i != e; ++i)
  2601.       if (!getTypeObject(i).getAttrs().empty())
  2602.         return true;
  2603.     return false;
  2604.   }
  2605.  
  2606.   /// Return a source range list of C++11 attributes associated
  2607.   /// with the declarator.
  2608.   void getCXX11AttributeRanges(SmallVectorImpl<SourceRange> &Ranges) {
  2609.     for (const ParsedAttr &AL : Attrs)
  2610.       if (AL.isCXX11Attribute())
  2611.         Ranges.push_back(AL.getRange());
  2612.   }
  2613.  
  2614.   void setAsmLabel(Expr *E) { AsmLabel = E; }
  2615.   Expr *getAsmLabel() const { return AsmLabel; }
  2616.  
  2617.   void setExtension(bool Val = true) { Extension = Val; }
  2618.   bool getExtension() const { return Extension; }
  2619.  
  2620.   void setObjCIvar(bool Val = true) { ObjCIvar = Val; }
  2621.   bool isObjCIvar() const { return ObjCIvar; }
  2622.  
  2623.   void setObjCWeakProperty(bool Val = true) { ObjCWeakProperty = Val; }
  2624.   bool isObjCWeakProperty() const { return ObjCWeakProperty; }
  2625.  
  2626.   void setInvalidType(bool Val = true) { InvalidType = Val; }
  2627.   bool isInvalidType() const {
  2628.     return InvalidType || DS.getTypeSpecType() == DeclSpec::TST_error;
  2629.   }
  2630.  
  2631.   void setGroupingParens(bool flag) { GroupingParens = flag; }
  2632.   bool hasGroupingParens() const { return GroupingParens; }
  2633.  
  2634.   bool isFirstDeclarator() const { return !CommaLoc.isValid(); }
  2635.   SourceLocation getCommaLoc() const { return CommaLoc; }
  2636.   void setCommaLoc(SourceLocation CL) { CommaLoc = CL; }
  2637.  
  2638.   bool hasEllipsis() const { return EllipsisLoc.isValid(); }
  2639.   SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
  2640.   void setEllipsisLoc(SourceLocation EL) { EllipsisLoc = EL; }
  2641.  
  2642.   void setFunctionDefinitionKind(FunctionDefinitionKind Val) {
  2643.     FunctionDefinition = static_cast<unsigned>(Val);
  2644.   }
  2645.  
  2646.   bool isFunctionDefinition() const {
  2647.     return getFunctionDefinitionKind() != FunctionDefinitionKind::Declaration;
  2648.   }
  2649.  
  2650.   FunctionDefinitionKind getFunctionDefinitionKind() const {
  2651.     return (FunctionDefinitionKind)FunctionDefinition;
  2652.   }
  2653.  
  2654.   void setHasInitializer(bool Val = true) { HasInitializer = Val; }
  2655.   bool hasInitializer() const { return HasInitializer; }
  2656.  
  2657.   /// Returns true if this declares a real member and not a friend.
  2658.   bool isFirstDeclarationOfMember() {
  2659.     return getContext() == DeclaratorContext::Member &&
  2660.            !getDeclSpec().isFriendSpecified();
  2661.   }
  2662.  
  2663.   /// Returns true if this declares a static member.  This cannot be called on a
  2664.   /// declarator outside of a MemberContext because we won't know until
  2665.   /// redeclaration time if the decl is static.
  2666.   bool isStaticMember();
  2667.  
  2668.   /// Returns true if this declares a constructor or a destructor.
  2669.   bool isCtorOrDtor();
  2670.  
  2671.   void setRedeclaration(bool Val) { Redeclaration = Val; }
  2672.   bool isRedeclaration() const { return Redeclaration; }
  2673. };
  2674.  
  2675. /// This little struct is used to capture information about
  2676. /// structure field declarators, which is basically just a bitfield size.
  2677. struct FieldDeclarator {
  2678.   Declarator D;
  2679.   Expr *BitfieldSize;
  2680.   explicit FieldDeclarator(const DeclSpec &DS,
  2681.                            const ParsedAttributes &DeclarationAttrs)
  2682.       : D(DS, DeclarationAttrs, DeclaratorContext::Member),
  2683.         BitfieldSize(nullptr) {}
  2684. };
  2685.  
  2686. /// Represents a C++11 virt-specifier-seq.
  2687. class VirtSpecifiers {
  2688. public:
  2689.   enum Specifier {
  2690.     VS_None = 0,
  2691.     VS_Override = 1,
  2692.     VS_Final = 2,
  2693.     VS_Sealed = 4,
  2694.     // Represents the __final keyword, which is legal for gcc in pre-C++11 mode.
  2695.     VS_GNU_Final = 8,
  2696.     VS_Abstract = 16
  2697.   };
  2698.  
  2699.   VirtSpecifiers() : Specifiers(0), LastSpecifier(VS_None) { }
  2700.  
  2701.   bool SetSpecifier(Specifier VS, SourceLocation Loc,
  2702.                     const char *&PrevSpec);
  2703.  
  2704.   bool isUnset() const { return Specifiers == 0; }
  2705.  
  2706.   bool isOverrideSpecified() const { return Specifiers & VS_Override; }
  2707.   SourceLocation getOverrideLoc() const { return VS_overrideLoc; }
  2708.  
  2709.   bool isFinalSpecified() const { return Specifiers & (VS_Final | VS_Sealed | VS_GNU_Final); }
  2710.   bool isFinalSpelledSealed() const { return Specifiers & VS_Sealed; }
  2711.   SourceLocation getFinalLoc() const { return VS_finalLoc; }
  2712.   SourceLocation getAbstractLoc() const { return VS_abstractLoc; }
  2713.  
  2714.   void clear() { Specifiers = 0; }
  2715.  
  2716.   static const char *getSpecifierName(Specifier VS);
  2717.  
  2718.   SourceLocation getFirstLocation() const { return FirstLocation; }
  2719.   SourceLocation getLastLocation() const { return LastLocation; }
  2720.   Specifier getLastSpecifier() const { return LastSpecifier; }
  2721.  
  2722. private:
  2723.   unsigned Specifiers;
  2724.   Specifier LastSpecifier;
  2725.  
  2726.   SourceLocation VS_overrideLoc, VS_finalLoc, VS_abstractLoc;
  2727.   SourceLocation FirstLocation;
  2728.   SourceLocation LastLocation;
  2729. };
  2730.  
  2731. enum class LambdaCaptureInitKind {
  2732.   NoInit,     //!< [a]
  2733.   CopyInit,   //!< [a = b], [a = {b}]
  2734.   DirectInit, //!< [a(b)]
  2735.   ListInit    //!< [a{b}]
  2736. };
  2737.  
  2738. /// Represents a complete lambda introducer.
  2739. struct LambdaIntroducer {
  2740.   /// An individual capture in a lambda introducer.
  2741.   struct LambdaCapture {
  2742.     LambdaCaptureKind Kind;
  2743.     SourceLocation Loc;
  2744.     IdentifierInfo *Id;
  2745.     SourceLocation EllipsisLoc;
  2746.     LambdaCaptureInitKind InitKind;
  2747.     ExprResult Init;
  2748.     ParsedType InitCaptureType;
  2749.     SourceRange ExplicitRange;
  2750.  
  2751.     LambdaCapture(LambdaCaptureKind Kind, SourceLocation Loc,
  2752.                   IdentifierInfo *Id, SourceLocation EllipsisLoc,
  2753.                   LambdaCaptureInitKind InitKind, ExprResult Init,
  2754.                   ParsedType InitCaptureType,
  2755.                   SourceRange ExplicitRange)
  2756.         : Kind(Kind), Loc(Loc), Id(Id), EllipsisLoc(EllipsisLoc),
  2757.           InitKind(InitKind), Init(Init), InitCaptureType(InitCaptureType),
  2758.           ExplicitRange(ExplicitRange) {}
  2759.   };
  2760.  
  2761.   SourceRange Range;
  2762.   SourceLocation DefaultLoc;
  2763.   LambdaCaptureDefault Default;
  2764.   SmallVector<LambdaCapture, 4> Captures;
  2765.  
  2766.   LambdaIntroducer()
  2767.     : Default(LCD_None) {}
  2768.  
  2769.   bool hasLambdaCapture() const {
  2770.     return Captures.size() > 0 || Default != LCD_None;
  2771.   }
  2772.  
  2773.   /// Append a capture in a lambda introducer.
  2774.   void addCapture(LambdaCaptureKind Kind,
  2775.                   SourceLocation Loc,
  2776.                   IdentifierInfo* Id,
  2777.                   SourceLocation EllipsisLoc,
  2778.                   LambdaCaptureInitKind InitKind,
  2779.                   ExprResult Init,
  2780.                   ParsedType InitCaptureType,
  2781.                   SourceRange ExplicitRange) {
  2782.     Captures.push_back(LambdaCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init,
  2783.                                      InitCaptureType, ExplicitRange));
  2784.   }
  2785. };
  2786.  
  2787. struct InventedTemplateParameterInfo {
  2788.   /// The number of parameters in the template parameter list that were
  2789.   /// explicitly specified by the user, as opposed to being invented by use
  2790.   /// of an auto parameter.
  2791.   unsigned NumExplicitTemplateParams = 0;
  2792.  
  2793.   /// If this is a generic lambda or abbreviated function template, use this
  2794.   /// as the depth of each 'auto' parameter, during initial AST construction.
  2795.   unsigned AutoTemplateParameterDepth = 0;
  2796.  
  2797.   /// Store the list of the template parameters for a generic lambda or an
  2798.   /// abbreviated function template.
  2799.   /// If this is a generic lambda or abbreviated function template, this holds
  2800.   /// the explicit template parameters followed by the auto parameters
  2801.   /// converted into TemplateTypeParmDecls.
  2802.   /// It can be used to construct the generic lambda or abbreviated template's
  2803.   /// template parameter list during initial AST construction.
  2804.   SmallVector<NamedDecl*, 4> TemplateParams;
  2805. };
  2806.  
  2807. } // end namespace clang
  2808.  
  2809. #endif // LLVM_CLANG_SEMA_DECLSPEC_H
  2810.