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