contrib/llvm/tools/clang/include/clang/Sema/DeclSpec.h

   1 //===--- DeclSpec.h - Parsed declaration specifiers -------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 ///
  10 /// \file
  11 /// \brief This file defines the classes used to store parsed information about
  12 /// declaration-specifiers and declarators.
  13 ///
  14 /// \verbatim
  15 ///   static const int volatile x, *y, *(*(*z)[10])(const void *x);
  16 ///   ------------------------- -  --  ---------------------------
  17 ///     declaration-specifiers  \  |   /
  18 ///                            declarators
  19 /// \endverbatim
  20 ///
  21 //===----------------------------------------------------------------------===//
  22
  23 #ifndef LLVM_CLANG_SEMA_DECLSPEC_H
  24 #define LLVM_CLANG_SEMA_DECLSPEC_H
  25
  26 #include "clang/AST/NestedNameSpecifier.h"
  27 #include "clang/Basic/ExceptionSpecificationType.h"
  28 #include "clang/Basic/Lambda.h"
  29 #include "clang/Basic/OperatorKinds.h"
  30 #include "clang/Basic/Specifiers.h"
  31 #include "clang/Lex/Token.h"
  32 #include "clang/Sema/AttributeList.h"
  33 #include "clang/Sema/Ownership.h"
  34 #include "llvm/ADT/SmallVector.h"
  35 #include "llvm/Support/Compiler.h"
  36 #include "llvm/Support/ErrorHandling.h"
  37
  38 namespace clang {
  39   class ASTContext;
  40   class TypeLoc;
  41   class LangOptions;
  42   class DiagnosticsEngine;
  43   class IdentifierInfo;
  44   class NamespaceAliasDecl;
  45   class NamespaceDecl;
  46   class NestedNameSpecifier;
  47   class NestedNameSpecifierLoc;
  48   class ObjCDeclSpec;
  49   class Preprocessor;
  50   class Sema;
  51   class Declarator;
  52   struct TemplateIdAnnotation;
  53
  54 /// \brief Represents a C++ nested-name-specifier or a global scope specifier.
  55 ///
  56 /// These can be in 3 states:
  57 ///   1) Not present, identified by isEmpty()
  58 ///   2) Present, identified by isNotEmpty()
  59 ///      2.a) Valid, idenified by isValid()
  60 ///      2.b) Invalid, identified by isInvalid().
  61 ///
  62 /// isSet() is deprecated because it mostly corresponded to "valid" but was
  63 /// often used as if it meant "present".
  64 ///
  65 /// The actual scope is described by getScopeRep().
  66 class CXXScopeSpec {
  67   SourceRange Range;
  68   NestedNameSpecifierLocBuilder Builder;
  69
  70 public:
  71   const SourceRange &getRange() const { return Range; }
  72   void setRange(const SourceRange &R) { Range = R; }
  73   void setBeginLoc(SourceLocation Loc) { Range.setBegin(Loc); }
  74   void setEndLoc(SourceLocation Loc) { Range.setEnd(Loc); }
  75   SourceLocation getBeginLoc() const { return Range.getBegin(); }
  76   SourceLocation getEndLoc() const { return Range.getEnd(); }
  77
  78   /// \brief Retrieve the representation of the nested-name-specifier.
  79   NestedNameSpecifier *getScopeRep() const {
  80     return Builder.getRepresentation();
  81   }
  82
  83   /// \brief Extend the current nested-name-specifier by another
  84   /// nested-name-specifier component of the form 'type::'.
  85   ///
  86   /// \param Context The AST context in which this nested-name-specifier
  87   /// resides.
  88   ///
  89   /// \param TemplateKWLoc The location of the 'template' keyword, if present.
  90   ///
  91   /// \param TL The TypeLoc that describes the type preceding the '::'.
  92   ///
  93   /// \param ColonColonLoc The location of the trailing '::'.
  94   void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL,
  95               SourceLocation ColonColonLoc);
  96
  97   /// \brief Extend the current nested-name-specifier by another
  98   /// nested-name-specifier component of the form 'identifier::'.
  99   ///
 100   /// \param Context The AST context in which this nested-name-specifier
 101   /// resides.
 102   ///
 103   /// \param Identifier The identifier.
 104   ///
 105   /// \param IdentifierLoc The location of the identifier.
 106   ///
 107   /// \param ColonColonLoc The location of the trailing '::'.
 108   void Extend(ASTContext &Context, IdentifierInfo *Identifier,
 109               SourceLocation IdentifierLoc, SourceLocation ColonColonLoc);
 110
 111   /// \brief Extend the current nested-name-specifier by another
 112   /// nested-name-specifier component of the form 'namespace::'.
 113   ///
 114   /// \param Context The AST context in which this nested-name-specifier
 115   /// resides.
 116   ///
 117   /// \param Namespace The namespace.
 118   ///
 119   /// \param NamespaceLoc The location of the namespace name.
 120   ///
 121   /// \param ColonColonLoc The location of the trailing '::'.
 122   void Extend(ASTContext &Context, NamespaceDecl *Namespace,
 123               SourceLocation NamespaceLoc, SourceLocation ColonColonLoc);
 124
 125   /// \brief Extend the current nested-name-specifier by another
 126   /// nested-name-specifier component of the form 'namespace-alias::'.
 127   ///
 128   /// \param Context The AST context in which this nested-name-specifier
 129   /// resides.
 130   ///
 131   /// \param Alias The namespace alias.
 132   ///
 133   /// \param AliasLoc The location of the namespace alias
 134   /// name.
 135   ///
 136   /// \param ColonColonLoc The location of the trailing '::'.
 137   void Extend(ASTContext &Context, NamespaceAliasDecl *Alias,
 138               SourceLocation AliasLoc, SourceLocation ColonColonLoc);
 139
 140   /// \brief Turn this (empty) nested-name-specifier into the global
 141   /// nested-name-specifier '::'.
 142   void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc);
 143
 144   /// \brief Make a new nested-name-specifier from incomplete source-location
 145   /// information.
 146   ///
 147   /// FIXME: This routine should be used very, very rarely, in cases where we
 148   /// need to synthesize a nested-name-specifier. Most code should instead use
 149   /// \c Adopt() with a proper \c NestedNameSpecifierLoc.
 150   void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier,
 151                    SourceRange R);
 152
 153   /// \brief Adopt an existing nested-name-specifier (with source-range
 154   /// information).
 155   void Adopt(NestedNameSpecifierLoc Other);
 156
 157   /// \brief Retrieve a nested-name-specifier with location information, copied
 158   /// into the given AST context.
 159   ///
 160   /// \param Context The context into which this nested-name-specifier will be
 161   /// copied.
 162   NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const;
 163
 164   /// \brief Retrieve the location of the name in the last qualifier
 165   /// in this nested name specifier.
 166   ///
 167   /// For example, the location of \c bar
 168   /// in
 169   /// \verbatim
 170   ///   \::foo::bar<0>::
 171   ///           ^~~
 172   /// \endverbatim
 173   SourceLocation getLastQualifierNameLoc() const;
 174
 175   /// No scope specifier.
 176   bool isEmpty() const { return !Range.isValid(); }
 177   /// A scope specifier is present, but may be valid or invalid.
 178   bool isNotEmpty() const { return !isEmpty(); }
 179
 180   /// An error occurred during parsing of the scope specifier.
 181   bool isInvalid() const { return isNotEmpty() && getScopeRep() == 0; }
 182   /// A scope specifier is present, and it refers to a real scope.
 183   bool isValid() const { return isNotEmpty() && getScopeRep() != 0; }
 184
 185   /// \brief Indicate that this nested-name-specifier is invalid.
 186   void SetInvalid(SourceRange R) {
 187     assert(R.isValid() && "Must have a valid source range");
 188     if (Range.getBegin().isInvalid())
 189       Range.setBegin(R.getBegin());
 190     Range.setEnd(R.getEnd());
 191     Builder.Clear();
 192   }
 193
 194   /// Deprecated.  Some call sites intend isNotEmpty() while others intend
 195   /// isValid().
 196   bool isSet() const { return getScopeRep() != 0; }
 197
 198   void clear() {
 199     Range = SourceRange();
 200     Builder.Clear();
 201   }
 202
 203   /// \brief Retrieve the data associated with the source-location information.
 204   char *location_data() const { return Builder.getBuffer().first; }
 205
 206   /// \brief Retrieve the size of the data associated with source-location
 207   /// information.
 208   unsigned location_size() const { return Builder.getBuffer().second; }
 209 };
 210
 211 /// \brief Captures information about "declaration specifiers".
 212 ///
 213 /// "Declaration specifiers" encompasses storage-class-specifiers,
 214 /// type-specifiers, type-qualifiers, and function-specifiers.
 215 class DeclSpec {
 216 public:
 217   /// \brief storage-class-specifier
 218   /// \note The order of these enumerators is important for diagnostics.
 219   enum SCS {
 220     SCS_unspecified = 0,
 221     SCS_typedef,
 222     SCS_extern,
 223     SCS_static,
 224     SCS_auto,
 225     SCS_register,
 226     SCS_private_extern,
 227     SCS_mutable
 228   };
 229
 230   // Import thread storage class specifier enumeration and constants.
 231   // These can be combined with SCS_extern and SCS_static.
 232   typedef ThreadStorageClassSpecifier TSCS;
 233   static const TSCS TSCS_unspecified = clang::TSCS_unspecified;
 234   static const TSCS TSCS___thread = clang::TSCS___thread;
 235   static const TSCS TSCS_thread_local = clang::TSCS_thread_local;
 236   static const TSCS TSCS__Thread_local = clang::TSCS__Thread_local;
 237
 238   // Import type specifier width enumeration and constants.
 239   typedef TypeSpecifierWidth TSW;
 240   static const TSW TSW_unspecified = clang::TSW_unspecified;
 241   static const TSW TSW_short = clang::TSW_short;
 242   static const TSW TSW_long = clang::TSW_long;
 243   static const TSW TSW_longlong = clang::TSW_longlong;
 244
 245   enum TSC {
 246     TSC_unspecified,
 247     TSC_imaginary,
 248     TSC_complex
 249   };
 250
 251   // Import type specifier sign enumeration and constants.
 252   typedef TypeSpecifierSign TSS;
 253   static const TSS TSS_unspecified = clang::TSS_unspecified;
 254   static const TSS TSS_signed = clang::TSS_signed;
 255   static const TSS TSS_unsigned = clang::TSS_unsigned;
 256
 257   // Import type specifier type enumeration and constants.
 258   typedef TypeSpecifierType TST;
 259   static const TST TST_unspecified = clang::TST_unspecified;
 260   static const TST TST_void = clang::TST_void;
 261   static const TST TST_char = clang::TST_char;
 262   static const TST TST_wchar = clang::TST_wchar;
 263   static const TST TST_char16 = clang::TST_char16;
 264   static const TST TST_char32 = clang::TST_char32;
 265   static const TST TST_int = clang::TST_int;
 266   static const TST TST_int128 = clang::TST_int128;
 267   static const TST TST_half = clang::TST_half;
 268   static const TST TST_float = clang::TST_float;
 269   static const TST TST_double = clang::TST_double;
 270   static const TST TST_bool = clang::TST_bool;
 271   static const TST TST_decimal32 = clang::TST_decimal32;
 272   static const TST TST_decimal64 = clang::TST_decimal64;
 273   static const TST TST_decimal128 = clang::TST_decimal128;
 274   static const TST TST_enum = clang::TST_enum;
 275   static const TST TST_union = clang::TST_union;
 276   static const TST TST_struct = clang::TST_struct;
 277   static const TST TST_interface = clang::TST_interface;
 278   static const TST TST_class = clang::TST_class;
 279   static const TST TST_typename = clang::TST_typename;
 280   static const TST TST_typeofType = clang::TST_typeofType;
 281   static const TST TST_typeofExpr = clang::TST_typeofExpr;
 282   static const TST TST_decltype = clang::TST_decltype;
 283   static const TST TST_decltype_auto = clang::TST_decltype_auto;
 284   static const TST TST_underlyingType = clang::TST_underlyingType;
 285   static const TST TST_auto = clang::TST_auto;
 286   static const TST TST_unknown_anytype = clang::TST_unknown_anytype;
 287   static const TST TST_atomic = clang::TST_atomic;
 288   static const TST TST_image1d_t = clang::TST_image1d_t;
 289   static const TST TST_image1d_array_t = clang::TST_image1d_array_t;
 290   static const TST TST_image1d_buffer_t = clang::TST_image1d_buffer_t;
 291   static const TST TST_image2d_t = clang::TST_image2d_t;
 292   static const TST TST_image2d_array_t = clang::TST_image2d_array_t;
 293   static const TST TST_image3d_t = clang::TST_image3d_t;
 294   static const TST TST_sampler_t = clang::TST_sampler_t;
 295   static const TST TST_event_t = clang::TST_event_t;
 296   static const TST TST_error = clang::TST_error;
 297
 298   // type-qualifiers
 299   enum TQ {   // NOTE: These flags must be kept in sync with Qualifiers::TQ.
 300     TQ_unspecified = 0,
 301     TQ_const       = 1,
 302     TQ_restrict    = 2,
 303     TQ_volatile    = 4,
 304     // This has no corresponding Qualifiers::TQ value, because it's not treated
 305     // as a qualifier in our type system.
 306     TQ_atomic      = 8
 307   };
 308
 309   /// ParsedSpecifiers - Flags to query which specifiers were applied.  This is
 310   /// returned by getParsedSpecifiers.
 311   enum ParsedSpecifiers {
 312     PQ_None                  = 0,
 313     PQ_StorageClassSpecifier = 1,
 314     PQ_TypeSpecifier         = 2,
 315     PQ_TypeQualifier         = 4,
 316     PQ_FunctionSpecifier     = 8
 317   };
 318
 319 private:
 320   // storage-class-specifier
 321   /*SCS*/unsigned StorageClassSpec : 3;
 322   /*TSCS*/unsigned ThreadStorageClassSpec : 2;
 323   unsigned SCS_extern_in_linkage_spec : 1;
 324
 325   // type-specifier
 326   /*TSW*/unsigned TypeSpecWidth : 2;
 327   /*TSC*/unsigned TypeSpecComplex : 2;
 328   /*TSS*/unsigned TypeSpecSign : 2;
 329   /*TST*/unsigned TypeSpecType : 6;
 330   unsigned TypeAltiVecVector : 1;
 331   unsigned TypeAltiVecPixel : 1;
 332   unsigned TypeAltiVecBool : 1;
 333   unsigned TypeSpecOwned : 1;
 334
 335   // type-qualifiers
 336   unsigned TypeQualifiers : 4;  // Bitwise OR of TQ.
 337
 338   // function-specifier
 339   unsigned FS_inline_specified : 1;
 340   unsigned FS_forceinline_specified: 1;
 341   unsigned FS_virtual_specified : 1;
 342   unsigned FS_explicit_specified : 1;
 343   unsigned FS_noreturn_specified : 1;
 344
 345   // friend-specifier
 346   unsigned Friend_specified : 1;
 347
 348   // constexpr-specifier
 349   unsigned Constexpr_specified : 1;
 350
 351   union {
 352     UnionParsedType TypeRep;
 353     Decl *DeclRep;
 354     Expr *ExprRep;
 355   };
 356
 357   // attributes.
 358   ParsedAttributes Attrs;
 359
 360   // Scope specifier for the type spec, if applicable.
 361   CXXScopeSpec TypeScope;
 362
 363   // List of protocol qualifiers for objective-c classes.  Used for
 364   // protocol-qualified interfaces "NString<foo>" and protocol-qualified id
 365   // "id<foo>".
 366   Decl * const *ProtocolQualifiers;
 367   unsigned NumProtocolQualifiers;
 368   SourceLocation ProtocolLAngleLoc;
 369   SourceLocation *ProtocolLocs;
 370
 371   // SourceLocation info.  These are null if the item wasn't specified or if
 372   // the setting was synthesized.
 373   SourceRange Range;
 374
 375   SourceLocation StorageClassSpecLoc, ThreadStorageClassSpecLoc;
 376   SourceLocation TSWLoc, TSCLoc, TSSLoc, TSTLoc, AltiVecLoc;
 377   /// TSTNameLoc - If TypeSpecType is any of class, enum, struct, union,
 378   /// typename, then this is the location of the named type (if present);
 379   /// otherwise, it is the same as TSTLoc. Hence, the pair TSTLoc and
 380   /// TSTNameLoc provides source range info for tag types.
 381   SourceLocation TSTNameLoc;
 382   SourceRange TypeofParensRange;
 383   SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc;
 384   SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc;
 385   SourceLocation FS_forceinlineLoc;
 386   SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc;
 387
 388   WrittenBuiltinSpecs writtenBS;
 389   void SaveWrittenBuiltinSpecs();
 390
 391   ObjCDeclSpec *ObjCQualifiers;
 392
 393   static bool isTypeRep(TST T) {
 394     return (T == TST_typename || T == TST_typeofType ||
 395             T == TST_underlyingType || T == TST_atomic);
 396   }
 397   static bool isExprRep(TST T) {
 398     return (T == TST_typeofExpr || T == TST_decltype);
 399   }
 400
 401   DeclSpec(const DeclSpec &) LLVM_DELETED_FUNCTION;
 402   void operator=(const DeclSpec &) LLVM_DELETED_FUNCTION;
 403 public:
 404   static bool isDeclRep(TST T) {
 405     return (T == TST_enum || T == TST_struct ||
 406             T == TST_interface || T == TST_union ||
 407             T == TST_class);
 408   }
 409
 410   DeclSpec(AttributeFactory &attrFactory)
 411     : StorageClassSpec(SCS_unspecified),
 412       ThreadStorageClassSpec(TSCS_unspecified),
 413       SCS_extern_in_linkage_spec(false),
 414       TypeSpecWidth(TSW_unspecified),
 415       TypeSpecComplex(TSC_unspecified),
 416       TypeSpecSign(TSS_unspecified),
 417       TypeSpecType(TST_unspecified),
 418       TypeAltiVecVector(false),
 419       TypeAltiVecPixel(false),
 420       TypeAltiVecBool(false),
 421       TypeSpecOwned(false),
 422       TypeQualifiers(TQ_unspecified),
 423       FS_inline_specified(false),
 424       FS_forceinline_specified(false),
 425       FS_virtual_specified(false),
 426       FS_explicit_specified(false),
 427       FS_noreturn_specified(false),
 428       Friend_specified(false),
 429       Constexpr_specified(false),
 430       Attrs(attrFactory),
 431       ProtocolQualifiers(0),
 432       NumProtocolQualifiers(0),
 433       ProtocolLocs(0),
 434       writtenBS(),
 435       ObjCQualifiers(0) {
 436   }
 437   ~DeclSpec() {
 438     delete [] ProtocolQualifiers;
 439     delete [] ProtocolLocs;
 440   }
 441   // storage-class-specifier
 442   SCS getStorageClassSpec() const { return (SCS)StorageClassSpec; }
 443   TSCS getThreadStorageClassSpec() const {
 444     return (TSCS)ThreadStorageClassSpec;
 445   }
 446   bool isExternInLinkageSpec() const { return SCS_extern_in_linkage_spec; }
 447   void setExternInLinkageSpec(bool Value) {
 448     SCS_extern_in_linkage_spec = Value;
 449   }
 450
 451   SourceLocation getStorageClassSpecLoc() const { return StorageClassSpecLoc; }
 452   SourceLocation getThreadStorageClassSpecLoc() const {
 453     return ThreadStorageClassSpecLoc;
 454   }
 455
 456   void ClearStorageClassSpecs() {
 457     StorageClassSpec           = DeclSpec::SCS_unspecified;
 458     ThreadStorageClassSpec     = DeclSpec::TSCS_unspecified;
 459     SCS_extern_in_linkage_spec = false;
 460     StorageClassSpecLoc        = SourceLocation();
 461     ThreadStorageClassSpecLoc  = SourceLocation();
 462   }
 463
 464   void ClearTypeSpecType() {
 465     TypeSpecType = DeclSpec::TST_unspecified;
 466     TypeSpecOwned = false;
 467     TSTLoc = SourceLocation();
 468   }
 469
 470   // type-specifier
 471   TSW getTypeSpecWidth() const { return (TSW)TypeSpecWidth; }
 472   TSC getTypeSpecComplex() const { return (TSC)TypeSpecComplex; }
 473   TSS getTypeSpecSign() const { return (TSS)TypeSpecSign; }
 474   TST getTypeSpecType() const { return (TST)TypeSpecType; }
 475   bool isTypeAltiVecVector() const { return TypeAltiVecVector; }
 476   bool isTypeAltiVecPixel() const { return TypeAltiVecPixel; }
 477   bool isTypeAltiVecBool() const { return TypeAltiVecBool; }
 478   bool isTypeSpecOwned() const { return TypeSpecOwned; }
 479   ParsedType getRepAsType() const {
 480     assert(isTypeRep((TST) TypeSpecType) && "DeclSpec does not store a type");
 481     return TypeRep;
 482   }
 483   Decl *getRepAsDecl() const {
 484     assert(isDeclRep((TST) TypeSpecType) && "DeclSpec does not store a decl");
 485     return DeclRep;
 486   }
 487   Expr *getRepAsExpr() const {
 488     assert(isExprRep((TST) TypeSpecType) && "DeclSpec does not store an expr");
 489     return ExprRep;
 490   }
 491   CXXScopeSpec &getTypeSpecScope() { return TypeScope; }
 492   const CXXScopeSpec &getTypeSpecScope() const { return TypeScope; }
 493
 494   const SourceRange &getSourceRange() const LLVM_READONLY { return Range; }
 495   SourceLocation getLocStart() const LLVM_READONLY { return Range.getBegin(); }
 496   SourceLocation getLocEnd() const LLVM_READONLY { return Range.getEnd(); }
 497
 498   SourceLocation getTypeSpecWidthLoc() const { return TSWLoc; }
 499   SourceLocation getTypeSpecComplexLoc() const { return TSCLoc; }
 500   SourceLocation getTypeSpecSignLoc() const { return TSSLoc; }
 501   SourceLocation getTypeSpecTypeLoc() const { return TSTLoc; }
 502   SourceLocation getAltiVecLoc() const { return AltiVecLoc; }
 503
 504   SourceLocation getTypeSpecTypeNameLoc() const {
 505     assert(isDeclRep((TST) TypeSpecType) || TypeSpecType == TST_typename);
 506     return TSTNameLoc;
 507   }
 508
 509   SourceRange getTypeofParensRange() const { return TypeofParensRange; }
 510   void setTypeofParensRange(SourceRange range) { TypeofParensRange = range; }
 511
 512   bool containsPlaceholderType() const {
 513     return TypeSpecType == TST_auto || TypeSpecType == TST_decltype_auto;
 514   }
 515
 516   bool hasTagDefinition() const;
 517
 518   /// \brief Turn a type-specifier-type into a string like "_Bool" or "union".
 519   static const char *getSpecifierName(DeclSpec::TST T);
 520   static const char *getSpecifierName(DeclSpec::TQ Q);
 521   static const char *getSpecifierName(DeclSpec::TSS S);
 522   static const char *getSpecifierName(DeclSpec::TSC C);
 523   static const char *getSpecifierName(DeclSpec::TSW W);
 524   static const char *getSpecifierName(DeclSpec::SCS S);
 525   static const char *getSpecifierName(DeclSpec::TSCS S);
 526
 527   // type-qualifiers
 528
 529   /// getTypeQualifiers - Return a set of TQs.
 530   unsigned getTypeQualifiers() const { return TypeQualifiers; }
 531   SourceLocation getConstSpecLoc() const { return TQ_constLoc; }
 532   SourceLocation getRestrictSpecLoc() const { return TQ_restrictLoc; }
 533   SourceLocation getVolatileSpecLoc() const { return TQ_volatileLoc; }
 534   SourceLocation getAtomicSpecLoc() const { return TQ_atomicLoc; }
 535
 536   /// \brief Clear out all of the type qualifiers.
 537   void ClearTypeQualifiers() {
 538     TypeQualifiers = 0;
 539     TQ_constLoc = SourceLocation();
 540     TQ_restrictLoc = SourceLocation();
 541     TQ_volatileLoc = SourceLocation();
 542     TQ_atomicLoc = SourceLocation();
 543   }
 544
 545   // function-specifier
 546   bool isInlineSpecified() const {
 547     return FS_inline_specified | FS_forceinline_specified;
 548   }
 549   SourceLocation getInlineSpecLoc() const {
 550     return FS_inline_specified ? FS_inlineLoc : FS_forceinlineLoc;
 551   }
 552
 553   bool isVirtualSpecified() const { return FS_virtual_specified; }
 554   SourceLocation getVirtualSpecLoc() const { return FS_virtualLoc; }
 555
 556   bool isExplicitSpecified() const { return FS_explicit_specified; }
 557   SourceLocation getExplicitSpecLoc() const { return FS_explicitLoc; }
 558
 559   bool isNoreturnSpecified() const { return FS_noreturn_specified; }
 560   SourceLocation getNoreturnSpecLoc() const { return FS_noreturnLoc; }
 561
 562   void ClearFunctionSpecs() {
 563     FS_inline_specified = false;
 564     FS_inlineLoc = SourceLocation();
 565     FS_forceinline_specified = false;
 566     FS_forceinlineLoc = SourceLocation();
 567     FS_virtual_specified = false;
 568     FS_virtualLoc = SourceLocation();
 569     FS_explicit_specified = false;
 570     FS_explicitLoc = SourceLocation();
 571     FS_noreturn_specified = false;
 572     FS_noreturnLoc = SourceLocation();
 573   }
 574
 575   /// \brief Return true if any type-specifier has been found.
 576   bool hasTypeSpecifier() const {
 577     return getTypeSpecType() != DeclSpec::TST_unspecified ||
 578            getTypeSpecWidth() != DeclSpec::TSW_unspecified ||
 579            getTypeSpecComplex() != DeclSpec::TSC_unspecified ||
 580            getTypeSpecSign() != DeclSpec::TSS_unspecified;
 581   }
 582
 583   /// \brief Return a bitmask of which flavors of specifiers this
 584   /// DeclSpec includes.
 585   unsigned getParsedSpecifiers() const;
 586
 587   /// isEmpty - Return true if this declaration specifier is completely empty:
 588   /// no tokens were parsed in the production of it.
 589   bool isEmpty() const {
 590     return getParsedSpecifiers() == DeclSpec::PQ_None;
 591   }
 592
 593   void SetRangeStart(SourceLocation Loc) { Range.setBegin(Loc); }
 594   void SetRangeEnd(SourceLocation Loc) { Range.setEnd(Loc); }
 595
 596   /// These methods set the specified attribute of the DeclSpec and
 597   /// return false if there was no error.  If an error occurs (for
 598   /// example, if we tried to set "auto" on a spec with "extern"
 599   /// already set), they return true and set PrevSpec and DiagID
 600   /// such that
 601   ///   Diag(Loc, DiagID) << PrevSpec;
 602   /// will yield a useful result.
 603   ///
 604   /// TODO: use a more general approach that still allows these
 605   /// diagnostics to be ignored when desired.
 606   bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
 607                            const char *&PrevSpec, unsigned &DiagID);
 608   bool SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc,
 609                                  const char *&PrevSpec, unsigned &DiagID);
 610   bool SetTypeSpecWidth(TSW W, SourceLocation Loc, const char *&PrevSpec,
 611                         unsigned &DiagID);
 612   bool SetTypeSpecComplex(TSC C, SourceLocation Loc, const char *&PrevSpec,
 613                           unsigned &DiagID);
 614   bool SetTypeSpecSign(TSS S, SourceLocation Loc, const char *&PrevSpec,
 615                        unsigned &DiagID);
 616   bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
 617                        unsigned &DiagID);
 618   bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
 619                        unsigned &DiagID, ParsedType Rep);
 620   bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
 621                        unsigned &DiagID, Decl *Rep, bool Owned);
 622   bool SetTypeSpecType(TST T, SourceLocation TagKwLoc,
 623                        SourceLocation TagNameLoc, const char *&PrevSpec,
 624                        unsigned &DiagID, ParsedType Rep);
 625   bool SetTypeSpecType(TST T, SourceLocation TagKwLoc,
 626                        SourceLocation TagNameLoc, const char *&PrevSpec,
 627                        unsigned &DiagID, Decl *Rep, bool Owned);
 628
 629   bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
 630                        unsigned &DiagID, Expr *Rep);
 631   bool SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
 632                        const char *&PrevSpec, unsigned &DiagID);
 633   bool SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
 634                        const char *&PrevSpec, unsigned &DiagID);
 635   bool SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
 636                        const char *&PrevSpec, unsigned &DiagID);
 637   bool SetTypeSpecError();
 638   void UpdateDeclRep(Decl *Rep) {
 639     assert(isDeclRep((TST) TypeSpecType));
 640     DeclRep = Rep;
 641   }
 642   void UpdateTypeRep(ParsedType Rep) {
 643     assert(isTypeRep((TST) TypeSpecType));
 644     TypeRep = Rep;
 645   }
 646   void UpdateExprRep(Expr *Rep) {
 647     assert(isExprRep((TST) TypeSpecType));
 648     ExprRep = Rep;
 649   }
 650
 651   bool SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
 652                    unsigned &DiagID, const LangOptions &Lang);
 653
 654   bool setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
 655                              unsigned &DiagID);
 656   bool setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
 657                                   unsigned &DiagID);
 658   bool setFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec,
 659                               unsigned &DiagID);
 660   bool setFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec,
 661                                unsigned &DiagID);
 662   bool setFunctionSpecNoreturn(SourceLocation Loc, const char *&PrevSpec,
 663                                unsigned &DiagID);
 664
 665   bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
 666                      unsigned &DiagID);
 667   bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
 668                             unsigned &DiagID);
 669   bool SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec,
 670                         unsigned &DiagID);
 671
 672   bool isFriendSpecified() const { return Friend_specified; }
 673   SourceLocation getFriendSpecLoc() const { return FriendLoc; }
 674
 675   bool isModulePrivateSpecified() const { return ModulePrivateLoc.isValid(); }
 676   SourceLocation getModulePrivateSpecLoc() const { return ModulePrivateLoc; }
 677
 678   bool isConstexprSpecified() const { return Constexpr_specified; }
 679   SourceLocation getConstexprSpecLoc() const { return ConstexprLoc; }
 680
 681   void ClearConstexprSpec() {
 682     Constexpr_specified = false;
 683     ConstexprLoc = SourceLocation();
 684   }
 685
 686   AttributePool &getAttributePool() const {
 687     return Attrs.getPool();
 688   }
 689
 690   /// \brief Concatenates two attribute lists.
 691   ///
 692   /// The GCC attribute syntax allows for the following:
 693   ///
 694   /// \code
 695   /// short __attribute__(( unused, deprecated ))
 696   /// int __attribute__(( may_alias, aligned(16) )) var;
 697   /// \endcode
 698   ///
 699   /// This declares 4 attributes using 2 lists. The following syntax is
 700   /// also allowed and equivalent to the previous declaration.
 701   ///
 702   /// \code
 703   /// short __attribute__((unused)) __attribute__((deprecated))
 704   /// int __attribute__((may_alias)) __attribute__((aligned(16))) var;
 705   /// \endcode
 706   ///
 707   void addAttributes(AttributeList *AL) {
 708     Attrs.addAll(AL);
 709   }
 710   void setAttributes(AttributeList *AL) {
 711     Attrs.set(AL);
 712   }
 713
 714   bool hasAttributes() const { return !Attrs.empty(); }
 715
 716   ParsedAttributes &getAttributes() { return Attrs; }
 717   const ParsedAttributes &getAttributes() const { return Attrs; }
 718
 719   /// \brief Return the current attribute list and remove them from
 720   /// the DeclSpec so that it doesn't own them.
 721   ParsedAttributes takeAttributes() {
 722     // The non-const "copy" constructor clears the operand automatically.
 723     return Attrs;
 724   }
 725
 726   void takeAttributesFrom(ParsedAttributes &attrs) {
 727     Attrs.takeAllFrom(attrs);
 728   }
 729
 730   typedef Decl * const *ProtocolQualifierListTy;
 731   ProtocolQualifierListTy getProtocolQualifiers() const {
 732     return ProtocolQualifiers;
 733   }
 734   SourceLocation *getProtocolLocs() const { return ProtocolLocs; }
 735   unsigned getNumProtocolQualifiers() const {
 736     return NumProtocolQualifiers;
 737   }
 738   SourceLocation getProtocolLAngleLoc() const { return ProtocolLAngleLoc; }
 739   void setProtocolQualifiers(Decl * const *Protos, unsigned NP,
 740                              SourceLocation *ProtoLocs,
 741                              SourceLocation LAngleLoc);
 742
 743   /// Finish - This does final analysis of the declspec, issuing diagnostics for
 744   /// things like "_Imaginary" (lacking an FP type).  After calling this method,
 745   /// DeclSpec is guaranteed self-consistent, even if an error occurred.
 746   void Finish(DiagnosticsEngine &D, Preprocessor &PP);
 747
 748   const WrittenBuiltinSpecs& getWrittenBuiltinSpecs() const {
 749     return writtenBS;
 750   }
 751
 752   ObjCDeclSpec *getObjCQualifiers() const { return ObjCQualifiers; }
 753   void setObjCQualifiers(ObjCDeclSpec *quals) { ObjCQualifiers = quals; }
 754
 755   /// \brief Checks if this DeclSpec can stand alone, without a Declarator.
 756   ///
 757   /// Only tag declspecs can stand alone.
 758   bool isMissingDeclaratorOk();
 759 };
 760
 761 /// \brief Captures information about "declaration specifiers" specific to
 762 /// Objective-C.
 763 class ObjCDeclSpec {
 764 public:
 765   /// ObjCDeclQualifier - Qualifier used on types in method
 766   /// declarations.  Not all combinations are sensible.  Parameters
 767   /// can be one of { in, out, inout } with one of { bycopy, byref }.
 768   /// Returns can either be { oneway } or not.
 769   ///
 770   /// This should be kept in sync with Decl::ObjCDeclQualifier.
 771   enum ObjCDeclQualifier {
 772     DQ_None = 0x0,
 773     DQ_In = 0x1,
 774     DQ_Inout = 0x2,
 775     DQ_Out = 0x4,
 776     DQ_Bycopy = 0x8,
 777     DQ_Byref = 0x10,
 778     DQ_Oneway = 0x20
 779   };
 780
 781   /// PropertyAttributeKind - list of property attributes.
 782   enum ObjCPropertyAttributeKind {
 783     DQ_PR_noattr = 0x0,
 784     DQ_PR_readonly = 0x01,
 785     DQ_PR_getter = 0x02,
 786     DQ_PR_assign = 0x04,
 787     DQ_PR_readwrite = 0x08,
 788     DQ_PR_retain = 0x10,
 789     DQ_PR_copy = 0x20,
 790     DQ_PR_nonatomic = 0x40,
 791     DQ_PR_setter = 0x80,
 792     DQ_PR_atomic = 0x100,
 793     DQ_PR_weak =   0x200,
 794     DQ_PR_strong = 0x400,
 795     DQ_PR_unsafe_unretained = 0x800
 796   };
 797
 798
 799   ObjCDeclSpec()
 800     : objcDeclQualifier(DQ_None), PropertyAttributes(DQ_PR_noattr),
 801       GetterName(0), SetterName(0) { }
 802   ObjCDeclQualifier getObjCDeclQualifier() const { return objcDeclQualifier; }
 803   void setObjCDeclQualifier(ObjCDeclQualifier DQVal) {
 804     objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier | DQVal);
 805   }
 806
 807   ObjCPropertyAttributeKind getPropertyAttributes() const {
 808     return ObjCPropertyAttributeKind(PropertyAttributes);
 809   }
 810   void setPropertyAttributes(ObjCPropertyAttributeKind PRVal) {
 811     PropertyAttributes =
 812       (ObjCPropertyAttributeKind)(PropertyAttributes | PRVal);
 813   }
 814
 815   const IdentifierInfo *getGetterName() const { return GetterName; }
 816   IdentifierInfo *getGetterName() { return GetterName; }
 817   void setGetterName(IdentifierInfo *name) { GetterName = name; }
 818
 819   const IdentifierInfo *getSetterName() const { return SetterName; }
 820   IdentifierInfo *getSetterName() { return SetterName; }
 821   void setSetterName(IdentifierInfo *name) { SetterName = name; }
 822
 823 private:
 824   // FIXME: These two are unrelated and mutially exclusive. So perhaps
 825   // we can put them in a union to reflect their mutual exclusiveness
 826   // (space saving is negligible).
 827   ObjCDeclQualifier objcDeclQualifier : 6;
 828
 829   // NOTE: VC++ treats enums as signed, avoid using ObjCPropertyAttributeKind
 830   unsigned PropertyAttributes : 12;
 831   IdentifierInfo *GetterName;    // getter name of NULL if no getter
 832   IdentifierInfo *SetterName;    // setter name of NULL if no setter
 833 };
 834
 835 /// \brief Represents a C++ unqualified-id that has been parsed.
 836 class UnqualifiedId {
 837 private:
 838   UnqualifiedId(const UnqualifiedId &Other) LLVM_DELETED_FUNCTION;
 839   const UnqualifiedId &operator=(const UnqualifiedId &) LLVM_DELETED_FUNCTION;
 840
 841 public:
 842   /// \brief Describes the kind of unqualified-id parsed.
 843   enum IdKind {
 844     /// \brief An identifier.
 845     IK_Identifier,
 846     /// \brief An overloaded operator name, e.g., operator+.
 847     IK_OperatorFunctionId,
 848     /// \brief A conversion function name, e.g., operator int.
 849     IK_ConversionFunctionId,
 850     /// \brief A user-defined literal name, e.g., operator "" _i.
 851     IK_LiteralOperatorId,
 852     /// \brief A constructor name.
 853     IK_ConstructorName,
 854     /// \brief A constructor named via a template-id.
 855     IK_ConstructorTemplateId,
 856     /// \brief A destructor name.
 857     IK_DestructorName,
 858     /// \brief A template-id, e.g., f<int>.
 859     IK_TemplateId,
 860     /// \brief An implicit 'self' parameter
 861     IK_ImplicitSelfParam
 862   } Kind;
 863
 864   struct OFI {
 865     /// \brief The kind of overloaded operator.
 866     OverloadedOperatorKind Operator;
 867
 868     /// \brief The source locations of the individual tokens that name
 869     /// the operator, e.g., the "new", "[", and "]" tokens in
 870     /// operator new [].
 871     ///
 872     /// Different operators have different numbers of tokens in their name,
 873     /// up to three. Any remaining source locations in this array will be
 874     /// set to an invalid value for operators with fewer than three tokens.
 875     unsigned SymbolLocations[3];
 876   };
 877
 878   /// \brief Anonymous union that holds extra data associated with the
 879   /// parsed unqualified-id.
 880   union {
 881     /// \brief When Kind == IK_Identifier, the parsed identifier, or when Kind
 882     /// == IK_UserLiteralId, the identifier suffix.
 883     IdentifierInfo *Identifier;
 884
 885     /// \brief When Kind == IK_OperatorFunctionId, the overloaded operator
 886     /// that we parsed.
 887     struct OFI OperatorFunctionId;
 888
 889     /// \brief When Kind == IK_ConversionFunctionId, the type that the
 890     /// conversion function names.
 891     UnionParsedType ConversionFunctionId;
 892
 893     /// \brief When Kind == IK_ConstructorName, the class-name of the type
 894     /// whose constructor is being referenced.
 895     UnionParsedType ConstructorName;
 896
 897     /// \brief When Kind == IK_DestructorName, the type referred to by the
 898     /// class-name.
 899     UnionParsedType DestructorName;
 900
 901     /// \brief When Kind == IK_TemplateId or IK_ConstructorTemplateId,
 902     /// the template-id annotation that contains the template name and
 903     /// template arguments.
 904     TemplateIdAnnotation *TemplateId;
 905   };
 906
 907   /// \brief The location of the first token that describes this unqualified-id,
 908   /// which will be the location of the identifier, "operator" keyword,
 909   /// tilde (for a destructor), or the template name of a template-id.
 910   SourceLocation StartLocation;
 911
 912   /// \brief The location of the last token that describes this unqualified-id.
 913   SourceLocation EndLocation;
 914
 915   UnqualifiedId() : Kind(IK_Identifier), Identifier(0) { }
 916
 917   /// \brief Clear out this unqualified-id, setting it to default (invalid)
 918   /// state.
 919   void clear() {
 920     Kind = IK_Identifier;
 921     Identifier = 0;
 922     StartLocation = SourceLocation();
 923     EndLocation = SourceLocation();
 924   }
 925
 926   /// \brief Determine whether this unqualified-id refers to a valid name.
 927   bool isValid() const { return StartLocation.isValid(); }
 928
 929   /// \brief Determine whether this unqualified-id refers to an invalid name.
 930   bool isInvalid() const { return !isValid(); }
 931
 932   /// \brief Determine what kind of name we have.
 933   IdKind getKind() const { return Kind; }
 934   void setKind(IdKind kind) { Kind = kind; }
 935
 936   /// \brief Specify that this unqualified-id was parsed as an identifier.
 937   ///
 938   /// \param Id the parsed identifier.
 939   /// \param IdLoc the location of the parsed identifier.
 940   void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc) {
 941     Kind = IK_Identifier;
 942     Identifier = const_cast<IdentifierInfo *>(Id);
 943     StartLocation = EndLocation = IdLoc;
 944   }
 945
 946   /// \brief Specify that this unqualified-id was parsed as an
 947   /// operator-function-id.
 948   ///
 949   /// \param OperatorLoc the location of the 'operator' keyword.
 950   ///
 951   /// \param Op the overloaded operator.
 952   ///
 953   /// \param SymbolLocations the locations of the individual operator symbols
 954   /// in the operator.
 955   void setOperatorFunctionId(SourceLocation OperatorLoc,
 956                              OverloadedOperatorKind Op,
 957                              SourceLocation SymbolLocations[3]);
 958
 959   /// \brief Specify that this unqualified-id was parsed as a
 960   /// conversion-function-id.
 961   ///
 962   /// \param OperatorLoc the location of the 'operator' keyword.
 963   ///
 964   /// \param Ty the type to which this conversion function is converting.
 965   ///
 966   /// \param EndLoc the location of the last token that makes up the type name.
 967   void setConversionFunctionId(SourceLocation OperatorLoc,
 968                                ParsedType Ty,
 969                                SourceLocation EndLoc) {
 970     Kind = IK_ConversionFunctionId;
 971     StartLocation = OperatorLoc;
 972     EndLocation = EndLoc;
 973     ConversionFunctionId = Ty;
 974   }
 975
 976   /// \brief Specific that this unqualified-id was parsed as a
 977   /// literal-operator-id.
 978   ///
 979   /// \param Id the parsed identifier.
 980   ///
 981   /// \param OpLoc the location of the 'operator' keyword.
 982   ///
 983   /// \param IdLoc the location of the identifier.
 984   void setLiteralOperatorId(const IdentifierInfo *Id, SourceLocation OpLoc,
 985                               SourceLocation IdLoc) {
 986     Kind = IK_LiteralOperatorId;
 987     Identifier = const_cast<IdentifierInfo *>(Id);
 988     StartLocation = OpLoc;
 989     EndLocation = IdLoc;
 990   }
 991
 992   /// \brief Specify that this unqualified-id was parsed as a constructor name.
 993   ///
 994   /// \param ClassType the class type referred to by the constructor name.
 995   ///
 996   /// \param ClassNameLoc the location of the class name.
 997   ///
 998   /// \param EndLoc the location of the last token that makes up the type name.
 999   void setConstructorName(ParsedType ClassType,
1000                           SourceLocation ClassNameLoc,
1001                           SourceLocation EndLoc) {
1002     Kind = IK_ConstructorName;
1003     StartLocation = ClassNameLoc;
1004     EndLocation = EndLoc;
1005     ConstructorName = ClassType;
1006   }
1007
1008   /// \brief Specify that this unqualified-id was parsed as a
1009   /// template-id that names a constructor.
1010   ///
1011   /// \param TemplateId the template-id annotation that describes the parsed
1012   /// template-id. This UnqualifiedId instance will take ownership of the
1013   /// \p TemplateId and will free it on destruction.
1014   void setConstructorTemplateId(TemplateIdAnnotation *TemplateId);
1015
1016   /// \brief Specify that this unqualified-id was parsed as a destructor name.
1017   ///
1018   /// \param TildeLoc the location of the '~' that introduces the destructor
1019   /// name.
1020   ///
1021   /// \param ClassType the name of the class referred to by the destructor name.
1022   void setDestructorName(SourceLocation TildeLoc,
1023                          ParsedType ClassType,
1024                          SourceLocation EndLoc) {
1025     Kind = IK_DestructorName;
1026     StartLocation = TildeLoc;
1027     EndLocation = EndLoc;
1028     DestructorName = ClassType;
1029   }
1030
1031   /// \brief Specify that this unqualified-id was parsed as a template-id.
1032   ///
1033   /// \param TemplateId the template-id annotation that describes the parsed
1034   /// template-id. This UnqualifiedId instance will take ownership of the
1035   /// \p TemplateId and will free it on destruction.
1036   void setTemplateId(TemplateIdAnnotation *TemplateId);
1037
1038   /// \brief Return the source range that covers this unqualified-id.
1039   SourceRange getSourceRange() const LLVM_READONLY {
1040     return SourceRange(StartLocation, EndLocation);
1041   }
1042   SourceLocation getLocStart() const LLVM_READONLY { return StartLocation; }
1043   SourceLocation getLocEnd() const LLVM_READONLY { return EndLocation; }
1044 };
1045
1046 /// \brief A set of tokens that has been cached for later parsing.
1047 typedef SmallVector<Token, 4> CachedTokens;
1048
1049 /// \brief One instance of this struct is used for each type in a
1050 /// declarator that is parsed.
1051 ///
1052 /// This is intended to be a small value object.
1053 struct DeclaratorChunk {
1054   enum {
1055     Pointer, Reference, Array, Function, BlockPointer, MemberPointer, Paren
1056   } Kind;
1057
1058   /// Loc - The place where this type was defined.
1059   SourceLocation Loc;
1060   /// EndLoc - If valid, the place where this chunck ends.
1061   SourceLocation EndLoc;
1062
1063   struct TypeInfoCommon {
1064     AttributeList *AttrList;
1065   };
1066
1067   struct PointerTypeInfo : TypeInfoCommon {
1068     /// The type qualifiers: const/volatile/restrict/atomic.
1069     unsigned TypeQuals : 4;
1070
1071     /// The location of the const-qualifier, if any.
1072     unsigned ConstQualLoc;
1073
1074     /// The location of the volatile-qualifier, if any.
1075     unsigned VolatileQualLoc;
1076
1077     /// The location of the restrict-qualifier, if any.
1078     unsigned RestrictQualLoc;
1079
1080     /// The location of the _Atomic-qualifier, if any.
1081     unsigned AtomicQualLoc;
1082
1083     void destroy() {
1084     }
1085   };
1086
1087   struct ReferenceTypeInfo : TypeInfoCommon {
1088     /// The type qualifier: restrict. [GNU] C++ extension
1089     bool HasRestrict : 1;
1090     /// True if this is an lvalue reference, false if it's an rvalue reference.
1091     bool LValueRef : 1;
1092     void destroy() {
1093     }
1094   };
1095
1096   struct ArrayTypeInfo : TypeInfoCommon {
1097     /// The type qualifiers for the array: const/volatile/restrict/_Atomic.
1098     unsigned TypeQuals : 4;
1099
1100     /// True if this dimension included the 'static' keyword.
1101     bool hasStatic : 1;
1102
1103     /// True if this dimension was [*].  In this case, NumElts is null.
1104     bool isStar : 1;
1105
1106     /// This is the size of the array, or null if [] or [*] was specified.
1107     /// Since the parser is multi-purpose, and we don't want to impose a root
1108     /// expression class on all clients, NumElts is untyped.
1109     Expr *NumElts;
1110
1111     void destroy() {}
1112   };
1113
1114   /// ParamInfo - An array of paraminfo objects is allocated whenever a function
1115   /// declarator is parsed.  There are two interesting styles of arguments here:
1116   /// K&R-style identifier lists and parameter type lists.  K&R-style identifier
1117   /// lists will have information about the identifier, but no type information.
1118   /// Parameter type lists will have type info (if the actions module provides
1119   /// it), but may have null identifier info: e.g. for 'void foo(int X, int)'.
1120   struct ParamInfo {
1121     IdentifierInfo *Ident;
1122     SourceLocation IdentLoc;
1123     Decl *Param;
1124
1125     /// DefaultArgTokens - When the parameter's default argument
1126     /// cannot be parsed immediately (because it occurs within the
1127     /// declaration of a member function), it will be stored here as a
1128     /// sequence of tokens to be parsed once the class definition is
1129     /// complete. Non-NULL indicates that there is a default argument.
1130     CachedTokens *DefaultArgTokens;
1131
1132     ParamInfo() {}
1133     ParamInfo(IdentifierInfo *ident, SourceLocation iloc,
1134               Decl *param,
1135               CachedTokens *DefArgTokens = 0)
1136       : Ident(ident), IdentLoc(iloc), Param(param),
1137         DefaultArgTokens(DefArgTokens) {}
1138   };
1139
1140   struct TypeAndRange {
1141     ParsedType Ty;
1142     SourceRange Range;
1143   };
1144
1145   struct FunctionTypeInfo : TypeInfoCommon {
1146     /// hasPrototype - This is true if the function had at least one typed
1147     /// argument.  If the function is () or (a,b,c), then it has no prototype,
1148     /// and is treated as a K&R-style function.
1149     unsigned hasPrototype : 1;
1150
1151     /// isVariadic - If this function has a prototype, and if that
1152     /// proto ends with ',...)', this is true. When true, EllipsisLoc
1153     /// contains the location of the ellipsis.
1154     unsigned isVariadic : 1;
1155
1156     /// Can this declaration be a constructor-style initializer?
1157     unsigned isAmbiguous : 1;
1158
1159     /// \brief Whether the ref-qualifier (if any) is an lvalue reference.
1160     /// Otherwise, it's an rvalue reference.
1161     unsigned RefQualifierIsLValueRef : 1;
1162
1163     /// The type qualifiers: const/volatile/restrict.
1164     /// The qualifier bitmask values are the same as in QualType.
1165     unsigned TypeQuals : 3;
1166
1167     /// ExceptionSpecType - An ExceptionSpecificationType value.
1168     unsigned ExceptionSpecType : 3;
1169
1170     /// DeleteArgInfo - If this is true, we need to delete[] ArgInfo.
1171     unsigned DeleteArgInfo : 1;
1172
1173     /// HasTrailingReturnType - If this is true, a trailing return type was
1174     /// specified.
1175     unsigned HasTrailingReturnType : 1;
1176
1177     /// The location of the left parenthesis in the source.
1178     unsigned LParenLoc;
1179
1180     /// When isVariadic is true, the location of the ellipsis in the source.
1181     unsigned EllipsisLoc;
1182
1183     /// The location of the right parenthesis in the source.
1184     unsigned RParenLoc;
1185
1186     /// NumArgs - This is the number of formal arguments provided for the
1187     /// declarator.
1188     unsigned NumArgs;
1189
1190     /// NumExceptions - This is the number of types in the dynamic-exception-
1191     /// decl, if the function has one.
1192     unsigned NumExceptions;
1193
1194     /// \brief The location of the ref-qualifier, if any.
1195     ///
1196     /// If this is an invalid location, there is no ref-qualifier.
1197     unsigned RefQualifierLoc;
1198
1199     /// \brief The location of the const-qualifier, if any.
1200     ///
1201     /// If this is an invalid location, there is no const-qualifier.
1202     unsigned ConstQualifierLoc;
1203
1204     /// \brief The location of the volatile-qualifier, if any.
1205     ///
1206     /// If this is an invalid location, there is no volatile-qualifier.
1207     unsigned VolatileQualifierLoc;
1208
1209     /// \brief The location of the 'mutable' qualifer in a lambda-declarator, if
1210     /// any.
1211     unsigned MutableLoc;
1212
1213     /// \brief The location of the keyword introducing the spec, if any.
1214     unsigned ExceptionSpecLoc;
1215
1216     /// ArgInfo - This is a pointer to a new[]'d array of ParamInfo objects that
1217     /// describe the arguments for this function declarator.  This is null if
1218     /// there are no arguments specified.
1219     ParamInfo *ArgInfo;
1220
1221     union {
1222       /// \brief Pointer to a new[]'d array of TypeAndRange objects that
1223       /// contain the types in the function's dynamic exception specification
1224       /// and their locations, if there is one.
1225       TypeAndRange *Exceptions;
1226
1227       /// \brief Pointer to the expression in the noexcept-specifier of this
1228       /// function, if it has one.
1229       Expr *NoexceptExpr;
1230     };
1231
1232     /// \brief If HasTrailingReturnType is true, this is the trailing return
1233     /// type specified.
1234     UnionParsedType TrailingReturnType;
1235
1236     /// \brief Reset the argument list to having zero arguments.
1237     ///
1238     /// This is used in various places for error recovery.
1239     void freeArgs() {
1240       if (DeleteArgInfo) {
1241         delete[] ArgInfo;
1242         DeleteArgInfo = false;
1243       }
1244       NumArgs = 0;
1245     }
1246
1247     void destroy() {
1248       if (DeleteArgInfo)
1249         delete[] ArgInfo;
1250       if (getExceptionSpecType() == EST_Dynamic)
1251         delete[] Exceptions;
1252     }
1253
1254     /// isKNRPrototype - Return true if this is a K&R style identifier list,
1255     /// like "void foo(a,b,c)".  In a function definition, this will be followed
1256     /// by the argument type definitions.
1257     bool isKNRPrototype() const {
1258       return !hasPrototype && NumArgs != 0;
1259     }
1260
1261     SourceLocation getLParenLoc() const {
1262       return SourceLocation::getFromRawEncoding(LParenLoc);
1263     }
1264
1265     SourceLocation getEllipsisLoc() const {
1266       return SourceLocation::getFromRawEncoding(EllipsisLoc);
1267     }
1268
1269     SourceLocation getRParenLoc() const {
1270       return SourceLocation::getFromRawEncoding(RParenLoc);
1271     }
1272
1273     SourceLocation getExceptionSpecLoc() const {
1274       return SourceLocation::getFromRawEncoding(ExceptionSpecLoc);
1275     }
1276
1277     /// \brief Retrieve the location of the ref-qualifier, if any.
1278     SourceLocation getRefQualifierLoc() const {
1279       return SourceLocation::getFromRawEncoding(RefQualifierLoc);
1280     }
1281
1282     /// \brief Retrieve the location of the ref-qualifier, if any.
1283     SourceLocation getConstQualifierLoc() const {
1284       return SourceLocation::getFromRawEncoding(ConstQualifierLoc);
1285     }
1286
1287     /// \brief Retrieve the location of the ref-qualifier, if any.
1288     SourceLocation getVolatileQualifierLoc() const {
1289       return SourceLocation::getFromRawEncoding(VolatileQualifierLoc);
1290     }
1291
1292     /// \brief Retrieve the location of the 'mutable' qualifier, if any.
1293     SourceLocation getMutableLoc() const {
1294       return SourceLocation::getFromRawEncoding(MutableLoc);
1295     }
1296
1297     /// \brief Determine whether this function declaration contains a
1298     /// ref-qualifier.
1299     bool hasRefQualifier() const { return getRefQualifierLoc().isValid(); }
1300
1301     /// \brief Determine whether this lambda-declarator contains a 'mutable'
1302     /// qualifier.
1303     bool hasMutableQualifier() const { return getMutableLoc().isValid(); }
1304
1305     /// \brief Get the type of exception specification this function has.
1306     ExceptionSpecificationType getExceptionSpecType() const {
1307       return static_cast<ExceptionSpecificationType>(ExceptionSpecType);
1308     }
1309
1310     /// \brief Determine whether this function declarator had a
1311     /// trailing-return-type.
1312     bool hasTrailingReturnType() const { return HasTrailingReturnType; }
1313
1314     /// \brief Get the trailing-return-type for this function declarator.
1315     ParsedType getTrailingReturnType() const { return TrailingReturnType; }
1316   };
1317
1318   struct BlockPointerTypeInfo : TypeInfoCommon {
1319     /// For now, sema will catch these as invalid.
1320     /// The type qualifiers: const/volatile/restrict/_Atomic.
1321     unsigned TypeQuals : 4;
1322
1323     void destroy() {
1324     }
1325   };
1326
1327   struct MemberPointerTypeInfo : TypeInfoCommon {
1328     /// The type qualifiers: const/volatile/restrict/_Atomic.
1329     unsigned TypeQuals : 4;
1330     // CXXScopeSpec has a constructor, so it can't be a direct member.
1331     // So we need some pointer-aligned storage and a bit of trickery.
1332     union {
1333       void *Aligner;
1334       char Mem[sizeof(CXXScopeSpec)];
1335     } ScopeMem;
1336     CXXScopeSpec &Scope() {
1337       return *reinterpret_cast<CXXScopeSpec*>(ScopeMem.Mem);
1338     }
1339     const CXXScopeSpec &Scope() const {
1340       return *reinterpret_cast<const CXXScopeSpec*>(ScopeMem.Mem);
1341     }
1342     void destroy() {
1343       Scope().~CXXScopeSpec();
1344     }
1345   };
1346
1347   union {
1348     TypeInfoCommon        Common;
1349     PointerTypeInfo       Ptr;
1350     ReferenceTypeInfo     Ref;
1351     ArrayTypeInfo         Arr;
1352     FunctionTypeInfo      Fun;
1353     BlockPointerTypeInfo  Cls;
1354     MemberPointerTypeInfo Mem;
1355   };
1356
1357   void destroy() {
1358     switch (Kind) {
1359     case DeclaratorChunk::Function:      return Fun.destroy();
1360     case DeclaratorChunk::Pointer:       return Ptr.destroy();
1361     case DeclaratorChunk::BlockPointer:  return Cls.destroy();
1362     case DeclaratorChunk::Reference:     return Ref.destroy();
1363     case DeclaratorChunk::Array:         return Arr.destroy();
1364     case DeclaratorChunk::MemberPointer: return Mem.destroy();
1365     case DeclaratorChunk::Paren:         return;
1366     }
1367   }
1368
1369   /// \brief If there are attributes applied to this declaratorchunk, return
1370   /// them.
1371   const AttributeList *getAttrs() const {
1372     return Common.AttrList;
1373   }
1374
1375   AttributeList *&getAttrListRef() {
1376     return Common.AttrList;
1377   }
1378
1379   /// \brief Return a DeclaratorChunk for a pointer.
1380   static DeclaratorChunk getPointer(unsigned TypeQuals, SourceLocation Loc,
1381                                     SourceLocation ConstQualLoc,
1382                                     SourceLocation VolatileQualLoc,
1383                                     SourceLocation RestrictQualLoc) {
1384     DeclaratorChunk I;
1385     I.Kind                = Pointer;
1386     I.Loc                 = Loc;
1387     I.Ptr.TypeQuals       = TypeQuals;
1388     I.Ptr.ConstQualLoc    = ConstQualLoc.getRawEncoding();
1389     I.Ptr.VolatileQualLoc = VolatileQualLoc.getRawEncoding();
1390     I.Ptr.RestrictQualLoc = RestrictQualLoc.getRawEncoding();
1391     I.Ptr.AttrList        = 0;
1392     return I;
1393   }
1394
1395   /// \brief Return a DeclaratorChunk for a reference.
1396   static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc,
1397                                       bool lvalue) {
1398     DeclaratorChunk I;
1399     I.Kind            = Reference;
1400     I.Loc             = Loc;
1401     I.Ref.HasRestrict = (TypeQuals & DeclSpec::TQ_restrict) != 0;
1402     I.Ref.LValueRef   = lvalue;
1403     I.Ref.AttrList    = 0;
1404     return I;
1405   }
1406
1407   /// \brief Return a DeclaratorChunk for an array.
1408   static DeclaratorChunk getArray(unsigned TypeQuals,
1409                                   bool isStatic, bool isStar, Expr *NumElts,
1410                                   SourceLocation LBLoc, SourceLocation RBLoc) {
1411     DeclaratorChunk I;
1412     I.Kind          = Array;
1413     I.Loc           = LBLoc;
1414     I.EndLoc        = RBLoc;
1415     I.Arr.AttrList  = 0;
1416     I.Arr.TypeQuals = TypeQuals;
1417     I.Arr.hasStatic = isStatic;
1418     I.Arr.isStar    = isStar;
1419     I.Arr.NumElts   = NumElts;
1420     return I;
1421   }
1422
1423   /// DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
1424   /// "TheDeclarator" is the declarator that this will be added to.
1425   static DeclaratorChunk getFunction(bool hasProto,
1426                                      bool isAmbiguous,
1427                                      SourceLocation LParenLoc,
1428                                      ParamInfo *ArgInfo, unsigned NumArgs,
1429                                      SourceLocation EllipsisLoc,
1430                                      SourceLocation RParenLoc,
1431                                      unsigned TypeQuals,
1432                                      bool RefQualifierIsLvalueRef,
1433                                      SourceLocation RefQualifierLoc,
1434                                      SourceLocation ConstQualifierLoc,
1435                                      SourceLocation VolatileQualifierLoc,
1436                                      SourceLocation MutableLoc,
1437                                      ExceptionSpecificationType ESpecType,
1438                                      SourceLocation ESpecLoc,
1439                                      ParsedType *Exceptions,
1440                                      SourceRange *ExceptionRanges,
1441                                      unsigned NumExceptions,
1442                                      Expr *NoexceptExpr,
1443                                      SourceLocation LocalRangeBegin,
1444                                      SourceLocation LocalRangeEnd,
1445                                      Declarator &TheDeclarator,
1446                                      TypeResult TrailingReturnType =
1447                                                     TypeResult());
1448
1449   /// \brief Return a DeclaratorChunk for a block.
1450   static DeclaratorChunk getBlockPointer(unsigned TypeQuals,
1451                                          SourceLocation Loc) {
1452     DeclaratorChunk I;
1453     I.Kind          = BlockPointer;
1454     I.Loc           = Loc;
1455     I.Cls.TypeQuals = TypeQuals;
1456     I.Cls.AttrList  = 0;
1457     return I;
1458   }
1459
1460   static DeclaratorChunk getMemberPointer(const CXXScopeSpec &SS,
1461                                           unsigned TypeQuals,
1462                                           SourceLocation Loc) {
1463     DeclaratorChunk I;
1464     I.Kind          = MemberPointer;
1465     I.Loc           = Loc;
1466     I.Mem.TypeQuals = TypeQuals;
1467     I.Mem.AttrList  = 0;
1468     new (I.Mem.ScopeMem.Mem) CXXScopeSpec(SS);
1469     return I;
1470   }
1471
1472   /// \brief Return a DeclaratorChunk for a paren.
1473   static DeclaratorChunk getParen(SourceLocation LParenLoc,
1474                                   SourceLocation RParenLoc) {
1475     DeclaratorChunk I;
1476     I.Kind          = Paren;
1477     I.Loc           = LParenLoc;
1478     I.EndLoc        = RParenLoc;
1479     I.Common.AttrList = 0;
1480     return I;
1481   }
1482
1483   bool isParen() const {
1484     return Kind == Paren;
1485   }
1486 };
1487
1488 /// \brief Described the kind of function definition (if any) provided for
1489 /// a function.
1490 enum FunctionDefinitionKind {
1491   FDK_Declaration,
1492   FDK_Definition,
1493   FDK_Defaulted,
1494   FDK_Deleted
1495 };
1496
1497 /// \brief Information about one declarator, including the parsed type
1498 /// information and the identifier.
1499 ///
1500 /// When the declarator is fully formed, this is turned into the appropriate
1501 /// Decl object.
1502 ///
1503 /// Declarators come in two types: normal declarators and abstract declarators.
1504 /// Abstract declarators are used when parsing types, and don't have an
1505 /// identifier.  Normal declarators do have ID's.
1506 ///
1507 /// Instances of this class should be a transient object that lives on the
1508 /// stack, not objects that are allocated in large quantities on the heap.
1509 class Declarator {
1510 public:
1511   enum TheContext {
1512     FileContext,         // File scope declaration.
1513     PrototypeContext,    // Within a function prototype.
1514     ObjCResultContext,   // An ObjC method result type.
1515     ObjCParameterContext,// An ObjC method parameter type.
1516     KNRTypeListContext,  // K&R type definition list for formals.
1517     TypeNameContext,     // Abstract declarator for types.
1518     MemberContext,       // Struct/Union field.
1519     BlockContext,        // Declaration within a block in a function.
1520     ForContext,          // Declaration within first part of a for loop.
1521     ConditionContext,    // Condition declaration in a C++ if/switch/while/for.
1522     TemplateParamContext,// Within a template parameter list.
1523     CXXNewContext,       // C++ new-expression.
1524     CXXCatchContext,     // C++ catch exception-declaration
1525     ObjCCatchContext,    // Objective-C catch exception-declaration
1526     BlockLiteralContext, // Block literal declarator.
1527     LambdaExprContext,   // Lambda-expression declarator.
1528     LambdaExprParameterContext, // Lambda-expression parameter declarator.
1529     ConversionIdContext, // C++ conversion-type-id.
1530     TrailingReturnContext, // C++11 trailing-type-specifier.
1531     TemplateTypeArgContext, // Template type argument.
1532     AliasDeclContext,    // C++11 alias-declaration.
1533     AliasTemplateContext // C++11 alias-declaration template.
1534   };
1535
1536 private:
1537   const DeclSpec &DS;
1538   CXXScopeSpec SS;
1539   UnqualifiedId Name;
1540   SourceRange Range;
1541
1542   /// \brief Where we are parsing this declarator.
1543   TheContext Context;
1544
1545   /// DeclTypeInfo - This holds each type that the declarator includes as it is
1546   /// parsed.  This is pushed from the identifier out, which means that element
1547   /// #0 will be the most closely bound to the identifier, and
1548   /// DeclTypeInfo.back() will be the least closely bound.
1549   SmallVector<DeclaratorChunk, 8> DeclTypeInfo;
1550
1551   /// InvalidType - Set by Sema::GetTypeForDeclarator().
1552   bool InvalidType : 1;
1553
1554   /// GroupingParens - Set by Parser::ParseParenDeclarator().
1555   bool GroupingParens : 1;
1556
1557   /// FunctionDefinition - Is this Declarator for a function or member
1558   /// definition and, if so, what kind?
1559   ///
1560   /// Actually a FunctionDefinitionKind.
1561   unsigned FunctionDefinition : 2;
1562
1563   /// \brief Is this Declarator a redeclaration?
1564   bool Redeclaration : 1;
1565
1566   /// Attrs - Attributes.
1567   ParsedAttributes Attrs;
1568
1569   /// \brief The asm label, if specified.
1570   Expr *AsmLabel;
1571
1572   /// InlineParams - This is a local array used for the first function decl
1573   /// chunk to avoid going to the heap for the common case when we have one
1574   /// function chunk in the declarator.
1575   DeclaratorChunk::ParamInfo InlineParams[16];
1576   bool InlineParamsUsed;
1577
1578   /// \brief true if the declaration is preceded by \c __extension__.
1579   bool Extension : 1;
1580
1581   /// \brief If this is the second or subsequent declarator in this declaration,
1582   /// the location of the comma before this declarator.
1583   SourceLocation CommaLoc;
1584
1585   /// \brief If provided, the source location of the ellipsis used to describe
1586   /// this declarator as a parameter pack.
1587   SourceLocation EllipsisLoc;
1588
1589   friend struct DeclaratorChunk;
1590
1591 public:
1592   Declarator(const DeclSpec &ds, TheContext C)
1593     : DS(ds), Range(ds.getSourceRange()), Context(C),
1594       InvalidType(DS.getTypeSpecType() == DeclSpec::TST_error),
1595       GroupingParens(false), FunctionDefinition(FDK_Declaration),
1596       Redeclaration(false),
1597       Attrs(ds.getAttributePool().getFactory()), AsmLabel(0),
1598       InlineParamsUsed(false), Extension(false) {
1599   }
1600
1601   ~Declarator() {
1602     clear();
1603   }
1604   /// getDeclSpec - Return the declaration-specifier that this declarator was
1605   /// declared with.
1606   const DeclSpec &getDeclSpec() const { return DS; }
1607
1608   /// getMutableDeclSpec - Return a non-const version of the DeclSpec.  This
1609   /// should be used with extreme care: declspecs can often be shared between
1610   /// multiple declarators, so mutating the DeclSpec affects all of the
1611   /// Declarators.  This should only be done when the declspec is known to not
1612   /// be shared or when in error recovery etc.
1613   DeclSpec &getMutableDeclSpec() { return const_cast<DeclSpec &>(DS); }
1614
1615   AttributePool &getAttributePool() const {
1616     return Attrs.getPool();
1617   }
1618
1619   /// getCXXScopeSpec - Return the C++ scope specifier (global scope or
1620   /// nested-name-specifier) that is part of the declarator-id.
1621   const CXXScopeSpec &getCXXScopeSpec() const { return SS; }
1622   CXXScopeSpec &getCXXScopeSpec() { return SS; }
1623
1624   /// \brief Retrieve the name specified by this declarator.
1625   UnqualifiedId &getName() { return Name; }
1626
1627   TheContext getContext() const { return Context; }
1628
1629   bool isPrototypeContext() const {
1630     return (Context == PrototypeContext ||
1631             Context == ObjCParameterContext ||
1632             Context == ObjCResultContext ||
1633             Context == LambdaExprParameterContext);
1634   }
1635
1636   /// \brief Get the source range that spans this declarator.
1637   const SourceRange &getSourceRange() const LLVM_READONLY { return Range; }
1638   SourceLocation getLocStart() const LLVM_READONLY { return Range.getBegin(); }
1639   SourceLocation getLocEnd() const LLVM_READONLY { return Range.getEnd(); }
1640
1641   void SetSourceRange(SourceRange R) { Range = R; }
1642   /// SetRangeBegin - Set the start of the source range to Loc, unless it's
1643   /// invalid.
1644   void SetRangeBegin(SourceLocation Loc) {
1645     if (!Loc.isInvalid())
1646       Range.setBegin(Loc);
1647   }
1648   /// SetRangeEnd - Set the end of the source range to Loc, unless it's invalid.
1649   void SetRangeEnd(SourceLocation Loc) {
1650     if (!Loc.isInvalid())
1651       Range.setEnd(Loc);
1652   }
1653   /// ExtendWithDeclSpec - Extend the declarator source range to include the
1654   /// given declspec, unless its location is invalid. Adopts the range start if
1655   /// the current range start is invalid.
1656   void ExtendWithDeclSpec(const DeclSpec &DS) {
1657     const SourceRange &SR = DS.getSourceRange();
1658     if (Range.getBegin().isInvalid())
1659       Range.setBegin(SR.getBegin());
1660     if (!SR.getEnd().isInvalid())
1661       Range.setEnd(SR.getEnd());
1662   }
1663
1664   /// \brief Reset the contents of this Declarator.
1665   void clear() {
1666     SS.clear();
1667     Name.clear();
1668     Range = DS.getSourceRange();
1669
1670     for (unsigned i = 0, e = DeclTypeInfo.size(); i != e; ++i)
1671       DeclTypeInfo[i].destroy();
1672     DeclTypeInfo.clear();
1673     Attrs.clear();
1674     AsmLabel = 0;
1675     InlineParamsUsed = false;
1676     CommaLoc = SourceLocation();
1677     EllipsisLoc = SourceLocation();
1678   }
1679
1680   /// mayOmitIdentifier - Return true if the identifier is either optional or
1681   /// not allowed.  This is true for typenames, prototypes, and template
1682   /// parameter lists.
1683   bool mayOmitIdentifier() const {
1684     switch (Context) {
1685     case FileContext:
1686     case KNRTypeListContext:
1687     case MemberContext:
1688     case BlockContext:
1689     case ForContext:
1690     case ConditionContext:
1691       return false;
1692
1693     case TypeNameContext:
1694     case AliasDeclContext:
1695     case AliasTemplateContext:
1696     case PrototypeContext:
1697     case LambdaExprParameterContext:
1698     case ObjCParameterContext:
1699     case ObjCResultContext:
1700     case TemplateParamContext:
1701     case CXXNewContext:
1702     case CXXCatchContext:
1703     case ObjCCatchContext:
1704     case BlockLiteralContext:
1705     case LambdaExprContext:
1706     case ConversionIdContext:
1707     case TemplateTypeArgContext:
1708     case TrailingReturnContext:
1709       return true;
1710     }
1711     llvm_unreachable("unknown context kind!");
1712   }
1713
1714   /// mayHaveIdentifier - Return true if the identifier is either optional or
1715   /// required.  This is true for normal declarators and prototypes, but not
1716   /// typenames.
1717   bool mayHaveIdentifier() const {
1718     switch (Context) {
1719     case FileContext:
1720     case KNRTypeListContext:
1721     case MemberContext:
1722     case BlockContext:
1723     case ForContext:
1724     case ConditionContext:
1725     case PrototypeContext:
1726     case LambdaExprParameterContext:
1727     case TemplateParamContext:
1728     case CXXCatchContext:
1729     case ObjCCatchContext:
1730       return true;
1731
1732     case TypeNameContext:
1733     case CXXNewContext:
1734     case AliasDeclContext:
1735     case AliasTemplateContext:
1736     case ObjCParameterContext:
1737     case ObjCResultContext:
1738     case BlockLiteralContext:
1739     case LambdaExprContext:
1740     case ConversionIdContext:
1741     case TemplateTypeArgContext:
1742     case TrailingReturnContext:
1743       return false;
1744     }
1745     llvm_unreachable("unknown context kind!");
1746   }
1747
1748   /// diagnoseIdentifier - Return true if the identifier is prohibited and
1749   /// should be diagnosed (because it cannot be anything else).
1750   bool diagnoseIdentifier() const {
1751     switch (Context) {
1752     case FileContext:
1753     case KNRTypeListContext:
1754     case MemberContext:
1755     case BlockContext:
1756     case ForContext:
1757     case ConditionContext:
1758     case PrototypeContext:
1759     case LambdaExprParameterContext:
1760     case TemplateParamContext:
1761     case CXXCatchContext:
1762     case ObjCCatchContext:
1763     case TypeNameContext:
1764     case ConversionIdContext:
1765     case ObjCParameterContext:
1766     case ObjCResultContext:
1767     case BlockLiteralContext:
1768     case CXXNewContext:
1769     case LambdaExprContext:
1770       return false;
1771
1772     case AliasDeclContext:
1773     case AliasTemplateContext:
1774     case TemplateTypeArgContext:
1775     case TrailingReturnContext:
1776       return true;
1777     }
1778     llvm_unreachable("unknown context kind!");
1779   }
1780
1781   /// mayBeFollowedByCXXDirectInit - Return true if the declarator can be
1782   /// followed by a C++ direct initializer, e.g. "int x(1);".
1783   bool mayBeFollowedByCXXDirectInit() const {
1784     if (hasGroupingParens()) return false;
1785
1786     if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
1787       return false;
1788
1789     if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern &&
1790         Context != FileContext)
1791       return false;
1792
1793     // Special names can't have direct initializers.
1794     if (Name.getKind() != UnqualifiedId::IK_Identifier)
1795       return false;
1796
1797     switch (Context) {
1798     case FileContext:
1799     case BlockContext:
1800     case ForContext:
1801       return true;
1802
1803     case ConditionContext:
1804       // This may not be followed by a direct initializer, but it can't be a
1805       // function declaration either, and we'd prefer to perform a tentative
1806       // parse in order to produce the right diagnostic.
1807       return true;
1808
1809     case KNRTypeListContext:
1810     case MemberContext:
1811     case PrototypeContext:
1812     case LambdaExprParameterContext:
1813     case ObjCParameterContext:
1814     case ObjCResultContext:
1815     case TemplateParamContext:
1816     case CXXCatchContext:
1817     case ObjCCatchContext:
1818     case TypeNameContext:
1819     case CXXNewContext:
1820     case AliasDeclContext:
1821     case AliasTemplateContext:
1822     case BlockLiteralContext:
1823     case LambdaExprContext:
1824     case ConversionIdContext:
1825     case TemplateTypeArgContext:
1826     case TrailingReturnContext:
1827       return false;
1828     }
1829     llvm_unreachable("unknown context kind!");
1830   }
1831
1832   /// isPastIdentifier - Return true if we have parsed beyond the point where
1833   /// the
1834   bool isPastIdentifier() const { return Name.isValid(); }
1835
1836   /// hasName - Whether this declarator has a name, which might be an
1837   /// identifier (accessible via getIdentifier()) or some kind of
1838   /// special C++ name (constructor, destructor, etc.).
1839   bool hasName() const {
1840     return Name.getKind() != UnqualifiedId::IK_Identifier || Name.Identifier;
1841   }
1842
1843   IdentifierInfo *getIdentifier() const {
1844     if (Name.getKind() == UnqualifiedId::IK_Identifier)
1845       return Name.Identifier;
1846
1847     return 0;
1848   }
1849   SourceLocation getIdentifierLoc() const { return Name.StartLocation; }
1850
1851   /// \brief Set the name of this declarator to be the given identifier.
1852   void SetIdentifier(IdentifierInfo *Id, SourceLocation IdLoc) {
1853     Name.setIdentifier(Id, IdLoc);
1854   }
1855
1856   /// AddTypeInfo - Add a chunk to this declarator. Also extend the range to
1857   /// EndLoc, which should be the last token of the chunk.
1858   void AddTypeInfo(const DeclaratorChunk &TI,
1859                    ParsedAttributes &attrs,
1860                    SourceLocation EndLoc) {
1861     DeclTypeInfo.push_back(TI);
1862     DeclTypeInfo.back().getAttrListRef() = attrs.getList();
1863     getAttributePool().takeAllFrom(attrs.getPool());
1864
1865     if (!EndLoc.isInvalid())
1866       SetRangeEnd(EndLoc);
1867   }
1868
1869   /// \brief Add a new innermost chunk to this declarator.
1870   void AddInnermostTypeInfo(const DeclaratorChunk &TI) {
1871     DeclTypeInfo.insert(DeclTypeInfo.begin(), TI);
1872   }
1873
1874   /// \brief Return the number of types applied to this declarator.
1875   unsigned getNumTypeObjects() const { return DeclTypeInfo.size(); }
1876
1877   /// Return the specified TypeInfo from this declarator.  TypeInfo #0 is
1878   /// closest to the identifier.
1879   const DeclaratorChunk &getTypeObject(unsigned i) const {
1880     assert(i < DeclTypeInfo.size() && "Invalid type chunk");
1881     return DeclTypeInfo[i];
1882   }
1883   DeclaratorChunk &getTypeObject(unsigned i) {
1884     assert(i < DeclTypeInfo.size() && "Invalid type chunk");
1885     return DeclTypeInfo[i];
1886   }
1887
1888   void DropFirstTypeObject() {
1889     assert(!DeclTypeInfo.empty() && "No type chunks to drop.");
1890     DeclTypeInfo.front().destroy();
1891     DeclTypeInfo.erase(DeclTypeInfo.begin());
1892   }
1893
1894   /// Return the innermost (closest to the declarator) chunk of this
1895   /// declarator that is not a parens chunk, or null if there are no
1896   /// non-parens chunks.
1897   const DeclaratorChunk *getInnermostNonParenChunk() const {
1898     for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
1899       if (!DeclTypeInfo[i].isParen())
1900         return &DeclTypeInfo[i];
1901     }
1902     return 0;
1903   }
1904
1905   /// Return the outermost (furthest from the declarator) chunk of
1906   /// this declarator that is not a parens chunk, or null if there are
1907   /// no non-parens chunks.
1908   const DeclaratorChunk *getOutermostNonParenChunk() const {
1909     for (unsigned i = DeclTypeInfo.size(), i_end = 0; i != i_end; --i) {
1910       if (!DeclTypeInfo[i-1].isParen())
1911         return &DeclTypeInfo[i-1];
1912     }
1913     return 0;
1914   }
1915
1916   /// isArrayOfUnknownBound - This method returns true if the declarator
1917   /// is a declarator for an array of unknown bound (looking through
1918   /// parentheses).
1919   bool isArrayOfUnknownBound() const {
1920     const DeclaratorChunk *chunk = getInnermostNonParenChunk();
1921     return (chunk && chunk->Kind == DeclaratorChunk::Array &&
1922             !chunk->Arr.NumElts);
1923   }
1924
1925   /// isFunctionDeclarator - This method returns true if the declarator
1926   /// is a function declarator (looking through parentheses).
1927   /// If true is returned, then the reference type parameter idx is
1928   /// assigned with the index of the declaration chunk.
1929   bool isFunctionDeclarator(unsigned& idx) const {
1930     for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
1931       switch (DeclTypeInfo[i].Kind) {
1932       case DeclaratorChunk::Function:
1933         idx = i;
1934         return true;
1935       case DeclaratorChunk::Paren:
1936         continue;
1937       case DeclaratorChunk::Pointer:
1938       case DeclaratorChunk::Reference:
1939       case DeclaratorChunk::Array:
1940       case DeclaratorChunk::BlockPointer:
1941       case DeclaratorChunk::MemberPointer:
1942         return false;
1943       }
1944       llvm_unreachable("Invalid type chunk");
1945     }
1946     return false;
1947   }
1948
1949   /// isFunctionDeclarator - Once this declarator is fully parsed and formed,
1950   /// this method returns true if the identifier is a function declarator
1951   /// (looking through parentheses).
1952   bool isFunctionDeclarator() const {
1953     unsigned index;
1954     return isFunctionDeclarator(index);
1955   }
1956
1957   /// getFunctionTypeInfo - Retrieves the function type info object
1958   /// (looking through parentheses).
1959   DeclaratorChunk::FunctionTypeInfo &getFunctionTypeInfo() {
1960     assert(isFunctionDeclarator() && "Not a function declarator!");
1961     unsigned index = 0;
1962     isFunctionDeclarator(index);
1963     return DeclTypeInfo[index].Fun;
1964   }
1965
1966   /// getFunctionTypeInfo - Retrieves the function type info object
1967   /// (looking through parentheses).
1968   const DeclaratorChunk::FunctionTypeInfo &getFunctionTypeInfo() const {
1969     return const_cast<Declarator*>(this)->getFunctionTypeInfo();
1970   }
1971
1972   /// \brief Determine whether the declaration that will be produced from
1973   /// this declaration will be a function.
1974   ///
1975   /// A declaration can declare a function even if the declarator itself
1976   /// isn't a function declarator, if the type specifier refers to a function
1977   /// type. This routine checks for both cases.
1978   bool isDeclarationOfFunction() const;
1979
1980   /// \brief Return true if this declaration appears in a context where a
1981   /// function declarator would be a function declaration.
1982   bool isFunctionDeclarationContext() const {
1983     if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
1984       return false;
1985
1986     switch (Context) {
1987     case FileContext:
1988     case MemberContext:
1989     case BlockContext:
1990       return true;
1991
1992     case ForContext:
1993     case ConditionContext:
1994     case KNRTypeListContext:
1995     case TypeNameContext:
1996     case AliasDeclContext:
1997     case AliasTemplateContext:
1998     case PrototypeContext:
1999     case LambdaExprParameterContext:
2000     case ObjCParameterContext:
2001     case ObjCResultContext:
2002     case TemplateParamContext:
2003     case CXXNewContext:
2004     case CXXCatchContext:
2005     case ObjCCatchContext:
2006     case BlockLiteralContext:
2007     case LambdaExprContext:
2008     case ConversionIdContext:
2009     case TemplateTypeArgContext:
2010     case TrailingReturnContext:
2011       return false;
2012     }
2013     llvm_unreachable("unknown context kind!");
2014   }
2015
2016   /// \brief Return true if a function declarator at this position would be a
2017   /// function declaration.
2018   bool isFunctionDeclaratorAFunctionDeclaration() const {
2019     if (!isFunctionDeclarationContext())
2020       return false;
2021
2022     for (unsigned I = 0, N = getNumTypeObjects(); I != N; ++I)
2023       if (getTypeObject(I).Kind != DeclaratorChunk::Paren)
2024         return false;
2025
2026     return true;
2027   }
2028
2029   /// takeAttributes - Takes attributes from the given parsed-attributes
2030   /// set and add them to this declarator.
2031   ///
2032   /// These examples both add 3 attributes to "var":
2033   ///  short int var __attribute__((aligned(16),common,deprecated));
2034   ///  short int x, __attribute__((aligned(16)) var
2035   ///                                 __attribute__((common,deprecated));
2036   ///
2037   /// Also extends the range of the declarator.
2038   void takeAttributes(ParsedAttributes &attrs, SourceLocation lastLoc) {
2039     Attrs.takeAllFrom(attrs);
2040
2041     if (!lastLoc.isInvalid())
2042       SetRangeEnd(lastLoc);
2043   }
2044
2045   const AttributeList *getAttributes() const { return Attrs.getList(); }
2046   AttributeList *getAttributes() { return Attrs.getList(); }
2047
2048   AttributeList *&getAttrListRef() { return Attrs.getListRef(); }
2049
2050   /// hasAttributes - do we contain any attributes?
2051   bool hasAttributes() const {
2052     if (getAttributes() || getDeclSpec().hasAttributes()) return true;
2053     for (unsigned i = 0, e = getNumTypeObjects(); i != e; ++i)
2054       if (getTypeObject(i).getAttrs())
2055         return true;
2056     return false;
2057   }
2058
2059   /// \brief Return a source range list of C++11 attributes associated
2060   /// with the declarator.
2061   void getCXX11AttributeRanges(SmallVectorImpl<SourceRange> &Ranges) {
2062     AttributeList *AttrList = Attrs.getList();
2063     while (AttrList) {
2064       if (AttrList->isCXX11Attribute())
2065         Ranges.push_back(AttrList->getRange());
2066       AttrList = AttrList->getNext();
2067     }
2068   }
2069
2070   void setAsmLabel(Expr *E) { AsmLabel = E; }
2071   Expr *getAsmLabel() const { return AsmLabel; }
2072
2073   void setExtension(bool Val = true) { Extension = Val; }
2074   bool getExtension() const { return Extension; }
2075
2076   void setInvalidType(bool Val = true) { InvalidType = Val; }
2077   bool isInvalidType() const {
2078     return InvalidType || DS.getTypeSpecType() == DeclSpec::TST_error;
2079   }
2080
2081   void setGroupingParens(bool flag) { GroupingParens = flag; }
2082   bool hasGroupingParens() const { return GroupingParens; }
2083
2084   bool isFirstDeclarator() const { return !CommaLoc.isValid(); }
2085   SourceLocation getCommaLoc() const { return CommaLoc; }
2086   void setCommaLoc(SourceLocation CL) { CommaLoc = CL; }
2087
2088   bool hasEllipsis() const { return EllipsisLoc.isValid(); }
2089   SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
2090   void setEllipsisLoc(SourceLocation EL) { EllipsisLoc = EL; }
2091
2092   void setFunctionDefinitionKind(FunctionDefinitionKind Val) {
2093     FunctionDefinition = Val;
2094   }
2095
2096   bool isFunctionDefinition() const {
2097     return getFunctionDefinitionKind() != FDK_Declaration;
2098   }
2099
2100   FunctionDefinitionKind getFunctionDefinitionKind() const {
2101     return (FunctionDefinitionKind)FunctionDefinition;
2102   }
2103
2104   /// Returns true if this declares a real member and not a friend.
2105   bool isFirstDeclarationOfMember() {
2106     return getContext() == MemberContext && !getDeclSpec().isFriendSpecified();
2107   }
2108
2109   /// Returns true if this declares a static member.  This cannot be called on a
2110   /// declarator outside of a MemberContext because we won't know until
2111   /// redeclaration time if the decl is static.
2112   bool isStaticMember();
2113
2114   void setRedeclaration(bool Val) { Redeclaration = Val; }
2115   bool isRedeclaration() const { return Redeclaration; }
2116 };
2117
2118 /// \brief This little struct is used to capture information about
2119 /// structure field declarators, which is basically just a bitfield size.
2120 struct FieldDeclarator {
2121   Declarator D;
2122   Expr *BitfieldSize;
2123   explicit FieldDeclarator(const DeclSpec &DS)
2124     : D(DS, Declarator::MemberContext), BitfieldSize(0) { }
2125 };
2126
2127 /// \brief Represents a C++11 virt-specifier-seq.
2128 class VirtSpecifiers {
2129 public:
2130   enum Specifier {
2131     VS_None = 0,
2132     VS_Override = 1,
2133     VS_Final = 2,
2134     VS_Sealed = 4
2135   };
2136
2137   VirtSpecifiers() : Specifiers(0) { }
2138
2139   bool SetSpecifier(Specifier VS, SourceLocation Loc,
2140                     const char *&PrevSpec);
2141
2142   bool isOverrideSpecified() const { return Specifiers & VS_Override; }
2143   SourceLocation getOverrideLoc() const { return VS_overrideLoc; }
2144
2145   bool isFinalSpecified() const { return Specifiers & (VS_Final | VS_Sealed); }
2146   bool isFinalSpelledSealed() const { return Specifiers & VS_Sealed; }
2147   SourceLocation getFinalLoc() const { return VS_finalLoc; }
2148
2149   void clear() { Specifiers = 0; }
2150
2151   static const char *getSpecifierName(Specifier VS);
2152
2153   SourceLocation getLastLocation() const { return LastLocation; }
2154
2155 private:
2156   unsigned Specifiers;
2157
2158   SourceLocation VS_overrideLoc, VS_finalLoc;
2159   SourceLocation LastLocation;
2160 };
2161
2162 /// \brief An individual capture in a lambda introducer.
2163 struct LambdaCapture {
2164   LambdaCaptureKind Kind;
2165   SourceLocation Loc;
2166   IdentifierInfo *Id;
2167   SourceLocation EllipsisLoc;
2168   ExprResult Init;
2169   ParsedType InitCaptureType;
2170   LambdaCapture(LambdaCaptureKind Kind, SourceLocation Loc,
2171                 IdentifierInfo* Id,
2172                 SourceLocation EllipsisLoc,
2173                 ExprResult Init, ParsedType InitCaptureType)
2174     : Kind(Kind), Loc(Loc), Id(Id), EllipsisLoc(EllipsisLoc), Init(Init),
2175         InitCaptureType(InitCaptureType)
2176   {}
2177 };
2178
2179 /// \brief Represents a complete lambda introducer.
2180 struct LambdaIntroducer {
2181   SourceRange Range;
2182   SourceLocation DefaultLoc;
2183   LambdaCaptureDefault Default;
2184   SmallVector<LambdaCapture, 4> Captures;
2185
2186   LambdaIntroducer()
2187     : Default(LCD_None) {}
2188
2189   /// \brief Append a capture in a lambda introducer.
2190   void addCapture(LambdaCaptureKind Kind,
2191                   SourceLocation Loc,
2192                   IdentifierInfo* Id,
2193                   SourceLocation EllipsisLoc,
2194                   ExprResult Init,
2195                   ParsedType InitCaptureType) {
2196     Captures.push_back(LambdaCapture(Kind, Loc, Id, EllipsisLoc, Init,
2197         InitCaptureType));
2198   }
2199 };
2200
2201 } // end namespace clang
2202
2203 #endif