contrib/llvm/tools/clang/lib/Parse/ParseDecl.cpp

   1 //===--- ParseDecl.cpp - Declaration Parsing ------------------------------===//
   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 implements the Declaration portions of the Parser interfaces.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Parse/Parser.h"
  15 #include "clang/Parse/ParseDiagnostic.h"
  16 #include "clang/Basic/OpenCL.h"
  17 #include "clang/Sema/Scope.h"
  18 #include "clang/Sema/ParsedTemplate.h"
  19 #include "clang/Sema/PrettyDeclStackTrace.h"
  20 #include "RAIIObjectsForParser.h"
  21 #include "llvm/ADT/SmallSet.h"
  22 #include "llvm/ADT/StringSwitch.h"
  23 using namespace clang;
  24
  25 //===----------------------------------------------------------------------===//
  26 // C99 6.7: Declarations.
  27 //===----------------------------------------------------------------------===//
  28
  29 /// ParseTypeName
  30 ///       type-name: [C99 6.7.6]
  31 ///         specifier-qualifier-list abstract-declarator[opt]
  32 ///
  33 /// Called type-id in C++.
  34 TypeResult Parser::ParseTypeName(SourceRange *Range,
  35                                  Declarator::TheContext Context,
  36                                  AccessSpecifier AS,
  37                                  Decl **OwnedType) {
  38   // Parse the common declaration-specifiers piece.
  39   DeclSpec DS(AttrFactory);
  40   ParseSpecifierQualifierList(DS, AS);
  41   if (OwnedType)
  42     *OwnedType = DS.isTypeSpecOwned() ? DS.getRepAsDecl() : 0;
  43
  44   // Parse the abstract-declarator, if present.
  45   Declarator DeclaratorInfo(DS, Context);
  46   ParseDeclarator(DeclaratorInfo);
  47   if (Range)
  48     *Range = DeclaratorInfo.getSourceRange();
  49
  50   if (DeclaratorInfo.isInvalidType())
  51     return true;
  52
  53   return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
  54 }
  55
  56
  57 /// isAttributeLateParsed - Return true if the attribute has arguments that
  58 /// require late parsing.
  59 static bool isAttributeLateParsed(const IdentifierInfo &II) {
  60     return llvm::StringSwitch<bool>(II.getName())
  61 #include "clang/Parse/AttrLateParsed.inc"
  62         .Default(false);
  63 }
  64
  65
  66 /// ParseGNUAttributes - Parse a non-empty attributes list.
  67 ///
  68 /// [GNU] attributes:
  69 ///         attribute
  70 ///         attributes attribute
  71 ///
  72 /// [GNU]  attribute:
  73 ///          '__attribute__' '(' '(' attribute-list ')' ')'
  74 ///
  75 /// [GNU]  attribute-list:
  76 ///          attrib
  77 ///          attribute_list ',' attrib
  78 ///
  79 /// [GNU]  attrib:
  80 ///          empty
  81 ///          attrib-name
  82 ///          attrib-name '(' identifier ')'
  83 ///          attrib-name '(' identifier ',' nonempty-expr-list ')'
  84 ///          attrib-name '(' argument-expression-list [C99 6.5.2] ')'
  85 ///
  86 /// [GNU]  attrib-name:
  87 ///          identifier
  88 ///          typespec
  89 ///          typequal
  90 ///          storageclass
  91 ///
  92 /// FIXME: The GCC grammar/code for this construct implies we need two
  93 /// token lookahead. Comment from gcc: "If they start with an identifier
  94 /// which is followed by a comma or close parenthesis, then the arguments
  95 /// start with that identifier; otherwise they are an expression list."
  96 ///
  97 /// At the moment, I am not doing 2 token lookahead. I am also unaware of
  98 /// any attributes that don't work (based on my limited testing). Most
  99 /// attributes are very simple in practice. Until we find a bug, I don't see
 100 /// a pressing need to implement the 2 token lookahead.
 101
 102 void Parser::ParseGNUAttributes(ParsedAttributes &attrs,
 103                                 SourceLocation *endLoc,
 104                                 LateParsedAttrList *LateAttrs) {
 105   assert(Tok.is(tok::kw___attribute) && "Not a GNU attribute list!");
 106
 107   while (Tok.is(tok::kw___attribute)) {
 108     ConsumeToken();
 109     if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
 110                          "attribute")) {
 111       SkipUntil(tok::r_paren, true); // skip until ) or ;
 112       return;
 113     }
 114     if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) {
 115       SkipUntil(tok::r_paren, true); // skip until ) or ;
 116       return;
 117     }
 118     // Parse the attribute-list. e.g. __attribute__(( weak, alias("__f") ))
 119     while (Tok.is(tok::identifier) || isDeclarationSpecifier() ||
 120            Tok.is(tok::comma)) {
 121       if (Tok.is(tok::comma)) {
 122         // allows for empty/non-empty attributes. ((__vector_size__(16),,,,))
 123         ConsumeToken();
 124         continue;
 125       }
 126       // we have an identifier or declaration specifier (const, int, etc.)
 127       IdentifierInfo *AttrName = Tok.getIdentifierInfo();
 128       SourceLocation AttrNameLoc = ConsumeToken();
 129
 130       if (Tok.is(tok::l_paren)) {
 131         // handle "parameterized" attributes
 132         if (LateAttrs && !ClassStack.empty() &&
 133             isAttributeLateParsed(*AttrName)) {
 134           // Delayed parsing is only available for attributes that occur
 135           // in certain locations within a class scope.
 136           LateParsedAttribute *LA =
 137             new LateParsedAttribute(this, *AttrName, AttrNameLoc);
 138           LateAttrs->push_back(LA);
 139           getCurrentClass().LateParsedDeclarations.push_back(LA);
 140
 141           // consume everything up to and including the matching right parens
 142           ConsumeAndStoreUntil(tok::r_paren, LA->Toks, true, false);
 143
 144           Token Eof;
 145           Eof.startToken();
 146           Eof.setLocation(Tok.getLocation());
 147           LA->Toks.push_back(Eof);
 148         } else {
 149           ParseGNUAttributeArgs(AttrName, AttrNameLoc, attrs, endLoc);
 150         }
 151       } else {
 152         attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc,
 153                      0, SourceLocation(), 0, 0);
 154       }
 155     }
 156     if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen))
 157       SkipUntil(tok::r_paren, false);
 158     SourceLocation Loc = Tok.getLocation();
 159     if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) {
 160       SkipUntil(tok::r_paren, false);
 161     }
 162     if (endLoc)
 163       *endLoc = Loc;
 164   }
 165 }
 166
 167
 168 /// Parse the arguments to a parameterized GNU attribute
 169 void Parser::ParseGNUAttributeArgs(IdentifierInfo *AttrName,
 170                                    SourceLocation AttrNameLoc,
 171                                    ParsedAttributes &Attrs,
 172                                    SourceLocation *EndLoc) {
 173
 174   assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
 175
 176   // Availability attributes have their own grammar.
 177   if (AttrName->isStr("availability")) {
 178     ParseAvailabilityAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc);
 179     return;
 180   }
 181   // Thread safety attributes fit into the FIXME case above, so we
 182   // just parse the arguments as a list of expressions
 183   if (IsThreadSafetyAttribute(AttrName->getName())) {
 184     ParseThreadSafetyAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc);
 185     return;
 186   }
 187
 188   ConsumeParen(); // ignore the left paren loc for now
 189
 190   if (Tok.is(tok::identifier)) {
 191     IdentifierInfo *ParmName = Tok.getIdentifierInfo();
 192     SourceLocation ParmLoc = ConsumeToken();
 193
 194     if (Tok.is(tok::r_paren)) {
 195       // __attribute__(( mode(byte) ))
 196       SourceLocation RParen = ConsumeParen();
 197       Attrs.addNew(AttrName, SourceRange(AttrNameLoc, RParen), 0, AttrNameLoc,
 198                    ParmName, ParmLoc, 0, 0);
 199     } else if (Tok.is(tok::comma)) {
 200       ConsumeToken();
 201       // __attribute__(( format(printf, 1, 2) ))
 202       ExprVector ArgExprs(Actions);
 203       bool ArgExprsOk = true;
 204
 205       // now parse the non-empty comma separated list of expressions
 206       while (1) {
 207         ExprResult ArgExpr(ParseAssignmentExpression());
 208         if (ArgExpr.isInvalid()) {
 209           ArgExprsOk = false;
 210           SkipUntil(tok::r_paren);
 211           break;
 212         } else {
 213           ArgExprs.push_back(ArgExpr.release());
 214         }
 215         if (Tok.isNot(tok::comma))
 216           break;
 217         ConsumeToken(); // Eat the comma, move to the next argument
 218       }
 219       if (ArgExprsOk && Tok.is(tok::r_paren)) {
 220         SourceLocation RParen = ConsumeParen();
 221         Attrs.addNew(AttrName, SourceRange(AttrNameLoc, RParen), 0, AttrNameLoc,
 222                      ParmName, ParmLoc, ArgExprs.take(), ArgExprs.size());
 223       }
 224     }
 225   } else { // not an identifier
 226     switch (Tok.getKind()) {
 227     case tok::r_paren: {
 228     // parse a possibly empty comma separated list of expressions
 229       // __attribute__(( nonnull() ))
 230       SourceLocation RParen = ConsumeParen();
 231       Attrs.addNew(AttrName, SourceRange(AttrNameLoc, RParen), 0, AttrNameLoc,
 232                    0, SourceLocation(), 0, 0);
 233       break;
 234     }
 235     case tok::kw_char:
 236     case tok::kw_wchar_t:
 237     case tok::kw_char16_t:
 238     case tok::kw_char32_t:
 239     case tok::kw_bool:
 240     case tok::kw_short:
 241     case tok::kw_int:
 242     case tok::kw_long:
 243     case tok::kw___int64:
 244     case tok::kw_signed:
 245     case tok::kw_unsigned:
 246     case tok::kw_float:
 247     case tok::kw_double:
 248     case tok::kw_void:
 249     case tok::kw_typeof: {
 250       // If it's a builtin type name, eat it and expect a rparen
 251       // __attribute__(( vec_type_hint(char) ))
 252       SourceLocation EndLoc = ConsumeToken();
 253       if (Tok.is(tok::r_paren))
 254         EndLoc = ConsumeParen();
 255       AttributeList *attr
 256         = Attrs.addNew(AttrName, SourceRange(AttrNameLoc, EndLoc), 0,
 257                        AttrNameLoc, 0, SourceLocation(), 0, 0);
 258       if (attr->getKind() == AttributeList::AT_IBOutletCollection)
 259         Diag(Tok, diag::err_iboutletcollection_builtintype);
 260       break;
 261     }
 262     default:
 263       // __attribute__(( aligned(16) ))
 264       ExprVector ArgExprs(Actions);
 265       bool ArgExprsOk = true;
 266
 267       // now parse the list of expressions
 268       while (1) {
 269         ExprResult ArgExpr(ParseAssignmentExpression());
 270         if (ArgExpr.isInvalid()) {
 271           ArgExprsOk = false;
 272           SkipUntil(tok::r_paren);
 273           break;
 274         } else {
 275           ArgExprs.push_back(ArgExpr.release());
 276         }
 277         if (Tok.isNot(tok::comma))
 278           break;
 279         ConsumeToken(); // Eat the comma, move to the next argument
 280       }
 281       // Match the ')'.
 282       if (ArgExprsOk && Tok.is(tok::r_paren)) {
 283         SourceLocation RParen = ConsumeParen();
 284         Attrs.addNew(AttrName, SourceRange(AttrNameLoc, RParen), 0,
 285                      AttrNameLoc, 0, SourceLocation(),
 286                      ArgExprs.take(), ArgExprs.size());
 287       }
 288       break;
 289     }
 290   }
 291 }
 292
 293
 294 /// ParseMicrosoftDeclSpec - Parse an __declspec construct
 295 ///
 296 /// [MS] decl-specifier:
 297 ///             __declspec ( extended-decl-modifier-seq )
 298 ///
 299 /// [MS] extended-decl-modifier-seq:
 300 ///             extended-decl-modifier[opt]
 301 ///             extended-decl-modifier extended-decl-modifier-seq
 302
 303 void Parser::ParseMicrosoftDeclSpec(ParsedAttributes &attrs) {
 304   assert(Tok.is(tok::kw___declspec) && "Not a declspec!");
 305
 306   ConsumeToken();
 307   if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
 308                        "declspec")) {
 309     SkipUntil(tok::r_paren, true); // skip until ) or ;
 310     return;
 311   }
 312
 313   while (Tok.getIdentifierInfo()) {
 314     IdentifierInfo *AttrName = Tok.getIdentifierInfo();
 315     SourceLocation AttrNameLoc = ConsumeToken();
 316
 317     // FIXME: Remove this when we have proper __declspec(property()) support.
 318     // Just skip everything inside property().
 319     if (AttrName->getName() == "property") {
 320       ConsumeParen();
 321       SkipUntil(tok::r_paren);
 322     }
 323     if (Tok.is(tok::l_paren)) {
 324       ConsumeParen();
 325       // FIXME: This doesn't parse __declspec(property(get=get_func_name))
 326       // correctly.
 327       ExprResult ArgExpr(ParseAssignmentExpression());
 328       if (!ArgExpr.isInvalid()) {
 329         Expr *ExprList = ArgExpr.take();
 330         attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0,
 331                      SourceLocation(), &ExprList, 1, true);
 332       }
 333       if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen))
 334         SkipUntil(tok::r_paren, false);
 335     } else {
 336       attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc,
 337                    0, SourceLocation(), 0, 0, true);
 338     }
 339   }
 340   if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen))
 341     SkipUntil(tok::r_paren, false);
 342   return;
 343 }
 344
 345 void Parser::ParseMicrosoftTypeAttributes(ParsedAttributes &attrs) {
 346   // Treat these like attributes
 347   // FIXME: Allow Sema to distinguish between these and real attributes!
 348   while (Tok.is(tok::kw___fastcall) || Tok.is(tok::kw___stdcall) ||
 349          Tok.is(tok::kw___thiscall) || Tok.is(tok::kw___cdecl)   ||
 350          Tok.is(tok::kw___ptr64) || Tok.is(tok::kw___w64) ||
 351          Tok.is(tok::kw___ptr32) ||
 352          Tok.is(tok::kw___unaligned)) {
 353     IdentifierInfo *AttrName = Tok.getIdentifierInfo();
 354     SourceLocation AttrNameLoc = ConsumeToken();
 355     if (Tok.is(tok::kw___ptr64) || Tok.is(tok::kw___w64) ||
 356         Tok.is(tok::kw___ptr32))
 357       // FIXME: Support these properly!
 358       continue;
 359     attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0,
 360                  SourceLocation(), 0, 0, true);
 361   }
 362 }
 363
 364 void Parser::ParseBorlandTypeAttributes(ParsedAttributes &attrs) {
 365   // Treat these like attributes
 366   while (Tok.is(tok::kw___pascal)) {
 367     IdentifierInfo *AttrName = Tok.getIdentifierInfo();
 368     SourceLocation AttrNameLoc = ConsumeToken();
 369     attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0,
 370                  SourceLocation(), 0, 0, true);
 371   }
 372 }
 373
 374 void Parser::ParseOpenCLAttributes(ParsedAttributes &attrs) {
 375   // Treat these like attributes
 376   while (Tok.is(tok::kw___kernel)) {
 377     SourceLocation AttrNameLoc = ConsumeToken();
 378     attrs.addNew(PP.getIdentifierInfo("opencl_kernel_function"),
 379                  AttrNameLoc, 0, AttrNameLoc, 0,
 380                  SourceLocation(), 0, 0, false);
 381   }
 382 }
 383
 384 void Parser::ParseOpenCLQualifiers(DeclSpec &DS) {
 385   SourceLocation Loc = Tok.getLocation();
 386   switch(Tok.getKind()) {
 387     // OpenCL qualifiers:
 388     case tok::kw___private:
 389     case tok::kw_private:
 390       DS.getAttributes().addNewInteger(
 391           Actions.getASTContext(),
 392           PP.getIdentifierInfo("address_space"), Loc, 0);
 393       break;
 394
 395     case tok::kw___global:
 396       DS.getAttributes().addNewInteger(
 397           Actions.getASTContext(),
 398           PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_global);
 399       break;
 400
 401     case tok::kw___local:
 402       DS.getAttributes().addNewInteger(
 403           Actions.getASTContext(),
 404           PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_local);
 405       break;
 406
 407     case tok::kw___constant:
 408       DS.getAttributes().addNewInteger(
 409           Actions.getASTContext(),
 410           PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_constant);
 411       break;
 412
 413     case tok::kw___read_only:
 414       DS.getAttributes().addNewInteger(
 415           Actions.getASTContext(),
 416           PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_read_only);
 417       break;
 418
 419     case tok::kw___write_only:
 420       DS.getAttributes().addNewInteger(
 421           Actions.getASTContext(),
 422           PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_write_only);
 423       break;
 424
 425     case tok::kw___read_write:
 426       DS.getAttributes().addNewInteger(
 427           Actions.getASTContext(),
 428           PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_read_write);
 429       break;
 430     default: break;
 431   }
 432 }
 433
 434 /// \brief Parse a version number.
 435 ///
 436 /// version:
 437 ///   simple-integer
 438 ///   simple-integer ',' simple-integer
 439 ///   simple-integer ',' simple-integer ',' simple-integer
 440 VersionTuple Parser::ParseVersionTuple(SourceRange &Range) {
 441   Range = Tok.getLocation();
 442
 443   if (!Tok.is(tok::numeric_constant)) {
 444     Diag(Tok, diag::err_expected_version);
 445     SkipUntil(tok::comma, tok::r_paren, true, true, true);
 446     return VersionTuple();
 447   }
 448
 449   // Parse the major (and possibly minor and subminor) versions, which
 450   // are stored in the numeric constant. We utilize a quirk of the
 451   // lexer, which is that it handles something like 1.2.3 as a single
 452   // numeric constant, rather than two separate tokens.
 453   llvm::SmallString<512> Buffer;
 454   Buffer.resize(Tok.getLength()+1);
 455   const char *ThisTokBegin = &Buffer[0];
 456
 457   // Get the spelling of the token, which eliminates trigraphs, etc.
 458   bool Invalid = false;
 459   unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin, &Invalid);
 460   if (Invalid)
 461     return VersionTuple();
 462
 463   // Parse the major version.
 464   unsigned AfterMajor = 0;
 465   unsigned Major = 0;
 466   while (AfterMajor < ActualLength && isdigit(ThisTokBegin[AfterMajor])) {
 467     Major = Major * 10 + ThisTokBegin[AfterMajor] - '0';
 468     ++AfterMajor;
 469   }
 470
 471   if (AfterMajor == 0) {
 472     Diag(Tok, diag::err_expected_version);
 473     SkipUntil(tok::comma, tok::r_paren, true, true, true);
 474     return VersionTuple();
 475   }
 476
 477   if (AfterMajor == ActualLength) {
 478     ConsumeToken();
 479
 480     // We only had a single version component.
 481     if (Major == 0) {
 482       Diag(Tok, diag::err_zero_version);
 483       return VersionTuple();
 484     }
 485
 486     return VersionTuple(Major);
 487   }
 488
 489   if (ThisTokBegin[AfterMajor] != '.' || (AfterMajor + 1 == ActualLength)) {
 490     Diag(Tok, diag::err_expected_version);
 491     SkipUntil(tok::comma, tok::r_paren, true, true, true);
 492     return VersionTuple();
 493   }
 494
 495   // Parse the minor version.
 496   unsigned AfterMinor = AfterMajor + 1;
 497   unsigned Minor = 0;
 498   while (AfterMinor < ActualLength && isdigit(ThisTokBegin[AfterMinor])) {
 499     Minor = Minor * 10 + ThisTokBegin[AfterMinor] - '0';
 500     ++AfterMinor;
 501   }
 502
 503   if (AfterMinor == ActualLength) {
 504     ConsumeToken();
 505
 506     // We had major.minor.
 507     if (Major == 0 && Minor == 0) {
 508       Diag(Tok, diag::err_zero_version);
 509       return VersionTuple();
 510     }
 511
 512     return VersionTuple(Major, Minor);
 513   }
 514
 515   // If what follows is not a '.', we have a problem.
 516   if (ThisTokBegin[AfterMinor] != '.') {
 517     Diag(Tok, diag::err_expected_version);
 518     SkipUntil(tok::comma, tok::r_paren, true, true, true);
 519     return VersionTuple();
 520   }
 521
 522   // Parse the subminor version.
 523   unsigned AfterSubminor = AfterMinor + 1;
 524   unsigned Subminor = 0;
 525   while (AfterSubminor < ActualLength && isdigit(ThisTokBegin[AfterSubminor])) {
 526     Subminor = Subminor * 10 + ThisTokBegin[AfterSubminor] - '0';
 527     ++AfterSubminor;
 528   }
 529
 530   if (AfterSubminor != ActualLength) {
 531     Diag(Tok, diag::err_expected_version);
 532     SkipUntil(tok::comma, tok::r_paren, true, true, true);
 533     return VersionTuple();
 534   }
 535   ConsumeToken();
 536   return VersionTuple(Major, Minor, Subminor);
 537 }
 538
 539 /// \brief Parse the contents of the "availability" attribute.
 540 ///
 541 /// availability-attribute:
 542 ///   'availability' '(' platform ',' version-arg-list ')'
 543 ///
 544 /// platform:
 545 ///   identifier
 546 ///
 547 /// version-arg-list:
 548 ///   version-arg
 549 ///   version-arg ',' version-arg-list
 550 ///
 551 /// version-arg:
 552 ///   'introduced' '=' version
 553 ///   'deprecated' '=' version
 554 ///   'removed' = version
 555 ///   'unavailable'
 556 void Parser::ParseAvailabilityAttribute(IdentifierInfo &Availability,
 557                                         SourceLocation AvailabilityLoc,
 558                                         ParsedAttributes &attrs,
 559                                         SourceLocation *endLoc) {
 560   SourceLocation PlatformLoc;
 561   IdentifierInfo *Platform = 0;
 562
 563   enum { Introduced, Deprecated, Obsoleted, Unknown };
 564   AvailabilityChange Changes[Unknown];
 565
 566   // Opening '('.
 567   BalancedDelimiterTracker T(*this, tok::l_paren);
 568   if (T.consumeOpen()) {
 569     Diag(Tok, diag::err_expected_lparen);
 570     return;
 571   }
 572
 573   // Parse the platform name,
 574   if (Tok.isNot(tok::identifier)) {
 575     Diag(Tok, diag::err_availability_expected_platform);
 576     SkipUntil(tok::r_paren);
 577     return;
 578   }
 579   Platform = Tok.getIdentifierInfo();
 580   PlatformLoc = ConsumeToken();
 581
 582   // Parse the ',' following the platform name.
 583   if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "", tok::r_paren))
 584     return;
 585
 586   // If we haven't grabbed the pointers for the identifiers
 587   // "introduced", "deprecated", and "obsoleted", do so now.
 588   if (!Ident_introduced) {
 589     Ident_introduced = PP.getIdentifierInfo("introduced");
 590     Ident_deprecated = PP.getIdentifierInfo("deprecated");
 591     Ident_obsoleted = PP.getIdentifierInfo("obsoleted");
 592     Ident_unavailable = PP.getIdentifierInfo("unavailable");
 593   }
 594
 595   // Parse the set of introductions/deprecations/removals.
 596   SourceLocation UnavailableLoc;
 597   do {
 598     if (Tok.isNot(tok::identifier)) {
 599       Diag(Tok, diag::err_availability_expected_change);
 600       SkipUntil(tok::r_paren);
 601       return;
 602     }
 603     IdentifierInfo *Keyword = Tok.getIdentifierInfo();
 604     SourceLocation KeywordLoc = ConsumeToken();
 605
 606     if (Keyword == Ident_unavailable) {
 607       if (UnavailableLoc.isValid()) {
 608         Diag(KeywordLoc, diag::err_availability_redundant)
 609           << Keyword << SourceRange(UnavailableLoc);
 610       }
 611       UnavailableLoc = KeywordLoc;
 612
 613       if (Tok.isNot(tok::comma))
 614         break;
 615
 616       ConsumeToken();
 617       continue;
 618     }
 619
 620     if (Tok.isNot(tok::equal)) {
 621       Diag(Tok, diag::err_expected_equal_after)
 622         << Keyword;
 623       SkipUntil(tok::r_paren);
 624       return;
 625     }
 626     ConsumeToken();
 627
 628     SourceRange VersionRange;
 629     VersionTuple Version = ParseVersionTuple(VersionRange);
 630
 631     if (Version.empty()) {
 632       SkipUntil(tok::r_paren);
 633       return;
 634     }
 635
 636     unsigned Index;
 637     if (Keyword == Ident_introduced)
 638       Index = Introduced;
 639     else if (Keyword == Ident_deprecated)
 640       Index = Deprecated;
 641     else if (Keyword == Ident_obsoleted)
 642       Index = Obsoleted;
 643     else
 644       Index = Unknown;
 645
 646     if (Index < Unknown) {
 647       if (!Changes[Index].KeywordLoc.isInvalid()) {
 648         Diag(KeywordLoc, diag::err_availability_redundant)
 649           << Keyword
 650           << SourceRange(Changes[Index].KeywordLoc,
 651                          Changes[Index].VersionRange.getEnd());
 652       }
 653
 654       Changes[Index].KeywordLoc = KeywordLoc;
 655       Changes[Index].Version = Version;
 656       Changes[Index].VersionRange = VersionRange;
 657     } else {
 658       Diag(KeywordLoc, diag::err_availability_unknown_change)
 659         << Keyword << VersionRange;
 660     }
 661
 662     if (Tok.isNot(tok::comma))
 663       break;
 664
 665     ConsumeToken();
 666   } while (true);
 667
 668   // Closing ')'.
 669   if (T.consumeClose())
 670     return;
 671
 672   if (endLoc)
 673     *endLoc = T.getCloseLocation();
 674
 675   // The 'unavailable' availability cannot be combined with any other
 676   // availability changes. Make sure that hasn't happened.
 677   if (UnavailableLoc.isValid()) {
 678     bool Complained = false;
 679     for (unsigned Index = Introduced; Index != Unknown; ++Index) {
 680       if (Changes[Index].KeywordLoc.isValid()) {
 681         if (!Complained) {
 682           Diag(UnavailableLoc, diag::warn_availability_and_unavailable)
 683             << SourceRange(Changes[Index].KeywordLoc,
 684                            Changes[Index].VersionRange.getEnd());
 685           Complained = true;
 686         }
 687
 688         // Clear out the availability.
 689         Changes[Index] = AvailabilityChange();
 690       }
 691     }
 692   }
 693
 694   // Record this attribute
 695   attrs.addNew(&Availability,
 696                SourceRange(AvailabilityLoc, T.getCloseLocation()),
 697                0, SourceLocation(),
 698                Platform, PlatformLoc,
 699                Changes[Introduced],
 700                Changes[Deprecated],
 701                Changes[Obsoleted],
 702                UnavailableLoc, false, false);
 703 }
 704
 705
 706 // Late Parsed Attributes:
 707 // See other examples of late parsing in lib/Parse/ParseCXXInlineMethods
 708
 709 void Parser::LateParsedDeclaration::ParseLexedAttributes() {}
 710
 711 void Parser::LateParsedClass::ParseLexedAttributes() {
 712   Self->ParseLexedAttributes(*Class);
 713 }
 714
 715 void Parser::LateParsedAttribute::ParseLexedAttributes() {
 716   Self->ParseLexedAttribute(*this);
 717 }
 718
 719 /// Wrapper class which calls ParseLexedAttribute, after setting up the
 720 /// scope appropriately.
 721 void Parser::ParseLexedAttributes(ParsingClass &Class) {
 722   // Deal with templates
 723   // FIXME: Test cases to make sure this does the right thing for templates.
 724   bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
 725   ParseScope ClassTemplateScope(this, Scope::TemplateParamScope,
 726                                 HasTemplateScope);
 727   if (HasTemplateScope)
 728     Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate);
 729
 730   // Set or update the scope flags to include Scope::ThisScope.
 731   bool AlreadyHasClassScope = Class.TopLevelClass;
 732   unsigned ScopeFlags = Scope::ClassScope|Scope::DeclScope|Scope::ThisScope;
 733   ParseScope ClassScope(this, ScopeFlags, !AlreadyHasClassScope);
 734   ParseScopeFlags ClassScopeFlags(this, ScopeFlags, AlreadyHasClassScope);
 735
 736   for (unsigned i = 0, ni = Class.LateParsedDeclarations.size(); i < ni; ++i) {
 737     Class.LateParsedDeclarations[i]->ParseLexedAttributes();
 738   }
 739 }
 740
 741 /// \brief Finish parsing an attribute for which parsing was delayed.
 742 /// This will be called at the end of parsing a class declaration
 743 /// for each LateParsedAttribute. We consume the saved tokens and
 744 /// create an attribute with the arguments filled in. We add this
 745 /// to the Attribute list for the decl.
 746 void Parser::ParseLexedAttribute(LateParsedAttribute &LA) {
 747   // Save the current token position.
 748   SourceLocation OrigLoc = Tok.getLocation();
 749
 750   // Append the current token at the end of the new token stream so that it
 751   // doesn't get lost.
 752   LA.Toks.push_back(Tok);
 753   PP.EnterTokenStream(LA.Toks.data(), LA.Toks.size(), true, false);
 754   // Consume the previously pushed token.
 755   ConsumeAnyToken();
 756
 757   ParsedAttributes Attrs(AttrFactory);
 758   SourceLocation endLoc;
 759
 760   // If the Decl is templatized, add template parameters to scope.
 761   bool HasTemplateScope = LA.D && LA.D->isTemplateDecl();
 762   ParseScope TempScope(this, Scope::TemplateParamScope, HasTemplateScope);
 763   if (HasTemplateScope)
 764     Actions.ActOnReenterTemplateScope(Actions.CurScope, LA.D);
 765
 766   // If the Decl is on a function, add function parameters to the scope.
 767   bool HasFunctionScope = LA.D && LA.D->isFunctionOrFunctionTemplate();
 768   ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope, HasFunctionScope);
 769   if (HasFunctionScope)
 770     Actions.ActOnReenterFunctionContext(Actions.CurScope, LA.D);
 771
 772   ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, &endLoc);
 773
 774   if (HasFunctionScope) {
 775     Actions.ActOnExitFunctionContext();
 776     FnScope.Exit();  // Pop scope, and remove Decls from IdResolver
 777   }
 778   if (HasTemplateScope) {
 779     TempScope.Exit();
 780   }
 781
 782   // Late parsed attributes must be attached to Decls by hand.  If the
 783   // LA.D is not set, then this was not done properly.
 784   assert(LA.D && "No decl attached to late parsed attribute");
 785   Actions.ActOnFinishDelayedAttribute(getCurScope(), LA.D, Attrs);
 786
 787   if (Tok.getLocation() != OrigLoc) {
 788     // Due to a parsing error, we either went over the cached tokens or
 789     // there are still cached tokens left, so we skip the leftover tokens.
 790     // Since this is an uncommon situation that should be avoided, use the
 791     // expensive isBeforeInTranslationUnit call.
 792     if (PP.getSourceManager().isBeforeInTranslationUnit(Tok.getLocation(),
 793                                                         OrigLoc))
 794     while (Tok.getLocation() != OrigLoc && Tok.isNot(tok::eof))
 795         ConsumeAnyToken();
 796   }
 797 }
 798
 799 /// \brief Wrapper around a case statement checking if AttrName is
 800 /// one of the thread safety attributes
 801 bool Parser::IsThreadSafetyAttribute(llvm::StringRef AttrName){
 802   return llvm::StringSwitch<bool>(AttrName)
 803       .Case("guarded_by", true)
 804       .Case("guarded_var", true)
 805       .Case("pt_guarded_by", true)
 806       .Case("pt_guarded_var", true)
 807       .Case("lockable", true)
 808       .Case("scoped_lockable", true)
 809       .Case("no_thread_safety_analysis", true)
 810       .Case("acquired_after", true)
 811       .Case("acquired_before", true)
 812       .Case("exclusive_lock_function", true)
 813       .Case("shared_lock_function", true)
 814       .Case("exclusive_trylock_function", true)
 815       .Case("shared_trylock_function", true)
 816       .Case("unlock_function", true)
 817       .Case("lock_returned", true)
 818       .Case("locks_excluded", true)
 819       .Case("exclusive_locks_required", true)
 820       .Case("shared_locks_required", true)
 821       .Default(false);
 822 }
 823
 824 /// \brief Parse the contents of thread safety attributes. These
 825 /// should always be parsed as an expression list.
 826 ///
 827 /// We need to special case the parsing due to the fact that if the first token
 828 /// of the first argument is an identifier, the main parse loop will store
 829 /// that token as a "parameter" and the rest of
 830 /// the arguments will be added to a list of "arguments". However,
 831 /// subsequent tokens in the first argument are lost. We instead parse each
 832 /// argument as an expression and add all arguments to the list of "arguments".
 833 /// In future, we will take advantage of this special case to also
 834 /// deal with some argument scoping issues here (for example, referring to a
 835 /// function parameter in the attribute on that function).
 836 void Parser::ParseThreadSafetyAttribute(IdentifierInfo &AttrName,
 837                                         SourceLocation AttrNameLoc,
 838                                         ParsedAttributes &Attrs,
 839                                         SourceLocation *EndLoc) {
 840   assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
 841
 842   BalancedDelimiterTracker T(*this, tok::l_paren);
 843   T.consumeOpen();
 844
 845   ExprVector ArgExprs(Actions);
 846   bool ArgExprsOk = true;
 847
 848   // now parse the list of expressions
 849   while (1) {
 850     ExprResult ArgExpr(ParseAssignmentExpression());
 851     if (ArgExpr.isInvalid()) {
 852       ArgExprsOk = false;
 853       T.consumeClose();
 854       break;
 855     } else {
 856       ArgExprs.push_back(ArgExpr.release());
 857     }
 858     if (Tok.isNot(tok::comma))
 859       break;
 860     ConsumeToken(); // Eat the comma, move to the next argument
 861   }
 862   // Match the ')'.
 863   if (ArgExprsOk && !T.consumeClose()) {
 864     Attrs.addNew(&AttrName, AttrNameLoc, 0, AttrNameLoc, 0, SourceLocation(),
 865                  ArgExprs.take(), ArgExprs.size());
 866   }
 867   if (EndLoc)
 868     *EndLoc = T.getCloseLocation();
 869 }
 870
 871 void Parser::DiagnoseProhibitedAttributes(ParsedAttributesWithRange &attrs) {
 872   Diag(attrs.Range.getBegin(), diag::err_attributes_not_allowed)
 873     << attrs.Range;
 874 }
 875
 876 /// ParseDeclaration - Parse a full 'declaration', which consists of
 877 /// declaration-specifiers, some number of declarators, and a semicolon.
 878 /// 'Context' should be a Declarator::TheContext value.  This returns the
 879 /// location of the semicolon in DeclEnd.
 880 ///
 881 ///       declaration: [C99 6.7]
 882 ///         block-declaration ->
 883 ///           simple-declaration
 884 ///           others                   [FIXME]
 885 /// [C++]   template-declaration
 886 /// [C++]   namespace-definition
 887 /// [C++]   using-directive
 888 /// [C++]   using-declaration
 889 /// [C++0x/C1X] static_assert-declaration
 890 ///         others... [FIXME]
 891 ///
 892 Parser::DeclGroupPtrTy Parser::ParseDeclaration(StmtVector &Stmts,
 893                                                 unsigned Context,
 894                                                 SourceLocation &DeclEnd,
 895                                           ParsedAttributesWithRange &attrs) {
 896   ParenBraceBracketBalancer BalancerRAIIObj(*this);
 897   // Must temporarily exit the objective-c container scope for
 898   // parsing c none objective-c decls.
 899   ObjCDeclContextSwitch ObjCDC(*this);
 900
 901   Decl *SingleDecl = 0;
 902   Decl *OwnedType = 0;
 903   switch (Tok.getKind()) {
 904   case tok::kw_template:
 905   case tok::kw_export:
 906     ProhibitAttributes(attrs);
 907     SingleDecl = ParseDeclarationStartingWithTemplate(Context, DeclEnd);
 908     break;
 909   case tok::kw_inline:
 910     // Could be the start of an inline namespace. Allowed as an ext in C++03.
 911     if (getLang().CPlusPlus && NextToken().is(tok::kw_namespace)) {
 912       ProhibitAttributes(attrs);
 913       SourceLocation InlineLoc = ConsumeToken();
 914       SingleDecl = ParseNamespace(Context, DeclEnd, InlineLoc);
 915       break;
 916     }
 917     return ParseSimpleDeclaration(Stmts, Context, DeclEnd, attrs,
 918                                   true);
 919   case tok::kw_namespace:
 920     ProhibitAttributes(attrs);
 921     SingleDecl = ParseNamespace(Context, DeclEnd);
 922     break;
 923   case tok::kw_using:
 924     SingleDecl = ParseUsingDirectiveOrDeclaration(Context, ParsedTemplateInfo(),
 925                                                   DeclEnd, attrs, &OwnedType);
 926     break;
 927   case tok::kw_static_assert:
 928   case tok::kw__Static_assert:
 929     ProhibitAttributes(attrs);
 930     SingleDecl = ParseStaticAssertDeclaration(DeclEnd);
 931     break;
 932   default:
 933     return ParseSimpleDeclaration(Stmts, Context, DeclEnd, attrs, true);
 934   }
 935
 936   // This routine returns a DeclGroup, if the thing we parsed only contains a
 937   // single decl, convert it now. Alias declarations can also declare a type;
 938   // include that too if it is present.
 939   return Actions.ConvertDeclToDeclGroup(SingleDecl, OwnedType);
 940 }
 941
 942 ///       simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl]
 943 ///         declaration-specifiers init-declarator-list[opt] ';'
 944 ///[C90/C++]init-declarator-list ';'                             [TODO]
 945 /// [OMP]   threadprivate-directive                              [TODO]
 946 ///
 947 ///       for-range-declaration: [C++0x 6.5p1: stmt.ranged]
 948 ///         attribute-specifier-seq[opt] type-specifier-seq declarator
 949 ///
 950 /// If RequireSemi is false, this does not check for a ';' at the end of the
 951 /// declaration.  If it is true, it checks for and eats it.
 952 ///
 953 /// If FRI is non-null, we might be parsing a for-range-declaration instead
 954 /// of a simple-declaration. If we find that we are, we also parse the
 955 /// for-range-initializer, and place it here.
 956 Parser::DeclGroupPtrTy Parser::ParseSimpleDeclaration(StmtVector &Stmts,
 957                                                       unsigned Context,
 958                                                       SourceLocation &DeclEnd,
 959                                                       ParsedAttributes &attrs,
 960                                                       bool RequireSemi,
 961                                                       ForRangeInit *FRI) {
 962   // Parse the common declaration-specifiers piece.
 963   ParsingDeclSpec DS(*this);
 964   DS.takeAttributesFrom(attrs);
 965
 966   ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none,
 967                              getDeclSpecContextFromDeclaratorContext(Context));
 968   StmtResult R = Actions.ActOnVlaStmt(DS);
 969   if (R.isUsable())
 970     Stmts.push_back(R.release());
 971
 972   // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };"
 973   // declaration-specifiers init-declarator-list[opt] ';'
 974   if (Tok.is(tok::semi)) {
 975     if (RequireSemi) ConsumeToken();
 976     Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none,
 977                                                        DS);
 978     DS.complete(TheDecl);
 979     return Actions.ConvertDeclToDeclGroup(TheDecl);
 980   }
 981
 982   return ParseDeclGroup(DS, Context, /*FunctionDefs=*/ false, &DeclEnd, FRI);
 983 }
 984
 985 /// ParseDeclGroup - Having concluded that this is either a function
 986 /// definition or a group of object declarations, actually parse the
 987 /// result.
 988 Parser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS,
 989                                               unsigned Context,
 990                                               bool AllowFunctionDefinitions,
 991                                               SourceLocation *DeclEnd,
 992                                               ForRangeInit *FRI) {
 993   // Parse the first declarator.
 994   ParsingDeclarator D(*this, DS, static_cast<Declarator::TheContext>(Context));
 995   ParseDeclarator(D);
 996
 997   // Bail out if the first declarator didn't seem well-formed.
 998   if (!D.hasName() && !D.mayOmitIdentifier()) {
 999     // Skip until ; or }.
1000     SkipUntil(tok::r_brace, true, true);
1001     if (Tok.is(tok::semi))
1002       ConsumeToken();
1003     return DeclGroupPtrTy();
1004   }
1005
1006   // Check to see if we have a function *definition* which must have a body.
1007   if (AllowFunctionDefinitions && D.isFunctionDeclarator() &&
1008       // Look at the next token to make sure that this isn't a function
1009       // declaration.  We have to check this because __attribute__ might be the
1010       // start of a function definition in GCC-extended K&R C.
1011       !isDeclarationAfterDeclarator()) {
1012
1013     if (isStartOfFunctionDefinition(D)) {
1014       if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
1015         Diag(Tok, diag::err_function_declared_typedef);
1016
1017         // Recover by treating the 'typedef' as spurious.
1018         DS.ClearStorageClassSpecs();
1019       }
1020
1021       Decl *TheDecl = ParseFunctionDefinition(D);
1022       return Actions.ConvertDeclToDeclGroup(TheDecl);
1023     }
1024
1025     if (isDeclarationSpecifier()) {
1026       // If there is an invalid declaration specifier right after the function
1027       // prototype, then we must be in a missing semicolon case where this isn't
1028       // actually a body.  Just fall through into the code that handles it as a
1029       // prototype, and let the top-level code handle the erroneous declspec
1030       // where it would otherwise expect a comma or semicolon.
1031     } else {
1032       Diag(Tok, diag::err_expected_fn_body);
1033       SkipUntil(tok::semi);
1034       return DeclGroupPtrTy();
1035     }
1036   }
1037
1038   if (ParseAttributesAfterDeclarator(D))
1039     return DeclGroupPtrTy();
1040
1041   // C++0x [stmt.iter]p1: Check if we have a for-range-declarator. If so, we
1042   // must parse and analyze the for-range-initializer before the declaration is
1043   // analyzed.
1044   if (FRI && Tok.is(tok::colon)) {
1045     FRI->ColonLoc = ConsumeToken();
1046     if (Tok.is(tok::l_brace))
1047       FRI->RangeExpr = ParseBraceInitializer();
1048     else
1049       FRI->RangeExpr = ParseExpression();
1050     Decl *ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
1051     Actions.ActOnCXXForRangeDecl(ThisDecl);
1052     Actions.FinalizeDeclaration(ThisDecl);
1053     return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, &ThisDecl, 1);
1054   }
1055
1056   SmallVector<Decl *, 8> DeclsInGroup;
1057   Decl *FirstDecl = ParseDeclarationAfterDeclaratorAndAttributes(D);
1058   D.complete(FirstDecl);
1059   if (FirstDecl)
1060     DeclsInGroup.push_back(FirstDecl);
1061
1062   // If we don't have a comma, it is either the end of the list (a ';') or an
1063   // error, bail out.
1064   while (Tok.is(tok::comma)) {
1065     // Consume the comma.
1066     ConsumeToken();
1067
1068     // Parse the next declarator.
1069     D.clear();
1070
1071     // Accept attributes in an init-declarator.  In the first declarator in a
1072     // declaration, these would be part of the declspec.  In subsequent
1073     // declarators, they become part of the declarator itself, so that they
1074     // don't apply to declarators after *this* one.  Examples:
1075     //    short __attribute__((common)) var;    -> declspec
1076     //    short var __attribute__((common));    -> declarator
1077     //    short x, __attribute__((common)) var;    -> declarator
1078     MaybeParseGNUAttributes(D);
1079
1080     ParseDeclarator(D);
1081
1082     Decl *ThisDecl = ParseDeclarationAfterDeclarator(D);
1083     D.complete(ThisDecl);
1084     if (ThisDecl)
1085       DeclsInGroup.push_back(ThisDecl);
1086   }
1087
1088   if (DeclEnd)
1089     *DeclEnd = Tok.getLocation();
1090
1091   if (Context != Declarator::ForContext &&
1092       ExpectAndConsume(tok::semi,
1093                        Context == Declarator::FileContext
1094                          ? diag::err_invalid_token_after_toplevel_declarator
1095                          : diag::err_expected_semi_declaration)) {
1096     // Okay, there was no semicolon and one was expected.  If we see a
1097     // declaration specifier, just assume it was missing and continue parsing.
1098     // Otherwise things are very confused and we skip to recover.
1099     if (!isDeclarationSpecifier()) {
1100       SkipUntil(tok::r_brace, true, true);
1101       if (Tok.is(tok::semi))
1102         ConsumeToken();
1103     }
1104   }
1105
1106   return Actions.FinalizeDeclaratorGroup(getCurScope(), DS,
1107                                          DeclsInGroup.data(),
1108                                          DeclsInGroup.size());
1109 }
1110
1111 /// Parse an optional simple-asm-expr and attributes, and attach them to a
1112 /// declarator. Returns true on an error.
1113 bool Parser::ParseAttributesAfterDeclarator(Declarator &D) {
1114   // If a simple-asm-expr is present, parse it.
1115   if (Tok.is(tok::kw_asm)) {
1116     SourceLocation Loc;
1117     ExprResult AsmLabel(ParseSimpleAsm(&Loc));
1118     if (AsmLabel.isInvalid()) {
1119       SkipUntil(tok::semi, true, true);
1120       return true;
1121     }
1122
1123     D.setAsmLabel(AsmLabel.release());
1124     D.SetRangeEnd(Loc);
1125   }
1126
1127   MaybeParseGNUAttributes(D);
1128   return false;
1129 }
1130
1131 /// \brief Parse 'declaration' after parsing 'declaration-specifiers
1132 /// declarator'. This method parses the remainder of the declaration
1133 /// (including any attributes or initializer, among other things) and
1134 /// finalizes the declaration.
1135 ///
1136 ///       init-declarator: [C99 6.7]
1137 ///         declarator
1138 ///         declarator '=' initializer
1139 /// [GNU]   declarator simple-asm-expr[opt] attributes[opt]
1140 /// [GNU]   declarator simple-asm-expr[opt] attributes[opt] '=' initializer
1141 /// [C++]   declarator initializer[opt]
1142 ///
1143 /// [C++] initializer:
1144 /// [C++]   '=' initializer-clause
1145 /// [C++]   '(' expression-list ')'
1146 /// [C++0x] '=' 'default'                                                [TODO]
1147 /// [C++0x] '=' 'delete'
1148 /// [C++0x] braced-init-list
1149 ///
1150 /// According to the standard grammar, =default and =delete are function
1151 /// definitions, but that definitely doesn't fit with the parser here.
1152 ///
1153 Decl *Parser::ParseDeclarationAfterDeclarator(Declarator &D,
1154                                      const ParsedTemplateInfo &TemplateInfo) {
1155   if (ParseAttributesAfterDeclarator(D))
1156     return 0;
1157
1158   return ParseDeclarationAfterDeclaratorAndAttributes(D, TemplateInfo);
1159 }
1160
1161 Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(Declarator &D,
1162                                      const ParsedTemplateInfo &TemplateInfo) {
1163   // Inform the current actions module that we just parsed this declarator.
1164   Decl *ThisDecl = 0;
1165   switch (TemplateInfo.Kind) {
1166   case ParsedTemplateInfo::NonTemplate:
1167     ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
1168     break;
1169
1170   case ParsedTemplateInfo::Template:
1171   case ParsedTemplateInfo::ExplicitSpecialization:
1172     ThisDecl = Actions.ActOnTemplateDeclarator(getCurScope(),
1173                              MultiTemplateParamsArg(Actions,
1174                                           TemplateInfo.TemplateParams->data(),
1175                                           TemplateInfo.TemplateParams->size()),
1176                                                D);
1177     break;
1178
1179   case ParsedTemplateInfo::ExplicitInstantiation: {
1180     DeclResult ThisRes
1181       = Actions.ActOnExplicitInstantiation(getCurScope(),
1182                                            TemplateInfo.ExternLoc,
1183                                            TemplateInfo.TemplateLoc,
1184                                            D);
1185     if (ThisRes.isInvalid()) {
1186       SkipUntil(tok::semi, true, true);
1187       return 0;
1188     }
1189
1190     ThisDecl = ThisRes.get();
1191     break;
1192     }
1193   }
1194
1195   bool TypeContainsAuto =
1196     D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto;
1197
1198   // Parse declarator '=' initializer.
1199   if (isTokenEqualOrMistypedEqualEqual(
1200                                diag::err_invalid_equalequal_after_declarator)) {
1201     ConsumeToken();
1202     if (Tok.is(tok::kw_delete)) {
1203       if (D.isFunctionDeclarator())
1204         Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
1205           << 1 /* delete */;
1206       else
1207         Diag(ConsumeToken(), diag::err_deleted_non_function);
1208     } else if (Tok.is(tok::kw_default)) {
1209       if (D.isFunctionDeclarator())
1210         Diag(Tok, diag::err_default_delete_in_multiple_declaration)
1211           << 1 /* delete */;
1212       else
1213         Diag(ConsumeToken(), diag::err_default_special_members);
1214     } else {
1215       if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) {
1216         EnterScope(0);
1217         Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
1218       }
1219
1220       if (Tok.is(tok::code_completion)) {
1221         Actions.CodeCompleteInitializer(getCurScope(), ThisDecl);
1222         cutOffParsing();
1223         return 0;
1224       }
1225
1226       ExprResult Init(ParseInitializer());
1227
1228       if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) {
1229         Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
1230         ExitScope();
1231       }
1232
1233       if (Init.isInvalid()) {
1234         SkipUntil(tok::comma, true, true);
1235         Actions.ActOnInitializerError(ThisDecl);
1236       } else
1237         Actions.AddInitializerToDecl(ThisDecl, Init.take(),
1238                                      /*DirectInit=*/false, TypeContainsAuto);
1239     }
1240   } else if (Tok.is(tok::l_paren)) {
1241     // Parse C++ direct initializer: '(' expression-list ')'
1242     BalancedDelimiterTracker T(*this, tok::l_paren);
1243     T.consumeOpen();
1244
1245     ExprVector Exprs(Actions);
1246     CommaLocsTy CommaLocs;
1247
1248     if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) {
1249       EnterScope(0);
1250       Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
1251     }
1252
1253     if (ParseExpressionList(Exprs, CommaLocs)) {
1254       SkipUntil(tok::r_paren);
1255
1256       if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) {
1257         Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
1258         ExitScope();
1259       }
1260     } else {
1261       // Match the ')'.
1262       T.consumeClose();
1263
1264       assert(!Exprs.empty() && Exprs.size()-1 == CommaLocs.size() &&
1265              "Unexpected number of commas!");
1266
1267       if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) {
1268         Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
1269         ExitScope();
1270       }
1271
1272       Actions.AddCXXDirectInitializerToDecl(ThisDecl, T.getOpenLocation(),
1273                                             move_arg(Exprs),
1274                                             T.getCloseLocation(),
1275                                             TypeContainsAuto);
1276     }
1277   } else if (getLang().CPlusPlus0x && Tok.is(tok::l_brace)) {
1278     // Parse C++0x braced-init-list.
1279     if (D.getCXXScopeSpec().isSet()) {
1280       EnterScope(0);
1281       Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
1282     }
1283
1284     ExprResult Init(ParseBraceInitializer());
1285
1286     if (D.getCXXScopeSpec().isSet()) {
1287       Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
1288       ExitScope();
1289     }
1290
1291     if (Init.isInvalid()) {
1292       Actions.ActOnInitializerError(ThisDecl);
1293     } else
1294       Actions.AddInitializerToDecl(ThisDecl, Init.take(),
1295                                    /*DirectInit=*/true, TypeContainsAuto);
1296
1297   } else {
1298     Actions.ActOnUninitializedDecl(ThisDecl, TypeContainsAuto);
1299   }
1300
1301   Actions.FinalizeDeclaration(ThisDecl);
1302
1303   return ThisDecl;
1304 }
1305
1306 /// ParseSpecifierQualifierList
1307 ///        specifier-qualifier-list:
1308 ///          type-specifier specifier-qualifier-list[opt]
1309 ///          type-qualifier specifier-qualifier-list[opt]
1310 /// [GNU]    attributes     specifier-qualifier-list[opt]
1311 ///
1312 void Parser::ParseSpecifierQualifierList(DeclSpec &DS, AccessSpecifier AS) {
1313   /// specifier-qualifier-list is a subset of declaration-specifiers.  Just
1314   /// parse declaration-specifiers and complain about extra stuff.
1315   /// TODO: diagnose attribute-specifiers and alignment-specifiers.
1316   ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS);
1317
1318   // Validate declspec for type-name.
1319   unsigned Specs = DS.getParsedSpecifiers();
1320   if (Specs == DeclSpec::PQ_None && !DS.getNumProtocolQualifiers() &&
1321       !DS.hasAttributes())
1322     Diag(Tok, diag::err_typename_requires_specqual);
1323
1324   // Issue diagnostic and remove storage class if present.
1325   if (Specs & DeclSpec::PQ_StorageClassSpecifier) {
1326     if (DS.getStorageClassSpecLoc().isValid())
1327       Diag(DS.getStorageClassSpecLoc(),diag::err_typename_invalid_storageclass);
1328     else
1329       Diag(DS.getThreadSpecLoc(), diag::err_typename_invalid_storageclass);
1330     DS.ClearStorageClassSpecs();
1331   }
1332
1333   // Issue diagnostic and remove function specfier if present.
1334   if (Specs & DeclSpec::PQ_FunctionSpecifier) {
1335     if (DS.isInlineSpecified())
1336       Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec);
1337     if (DS.isVirtualSpecified())
1338       Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_functionspec);
1339     if (DS.isExplicitSpecified())
1340       Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_functionspec);
1341     DS.ClearFunctionSpecs();
1342   }
1343 }
1344
1345 /// isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the
1346 /// specified token is valid after the identifier in a declarator which
1347 /// immediately follows the declspec.  For example, these things are valid:
1348 ///
1349 ///      int x   [             4];         // direct-declarator
1350 ///      int x   (             int y);     // direct-declarator
1351 ///  int(int x   )                         // direct-declarator
1352 ///      int x   ;                         // simple-declaration
1353 ///      int x   =             17;         // init-declarator-list
1354 ///      int x   ,             y;          // init-declarator-list
1355 ///      int x   __asm__       ("foo");    // init-declarator-list
1356 ///      int x   :             4;          // struct-declarator
1357 ///      int x   {             5};         // C++'0x unified initializers
1358 ///
1359 /// This is not, because 'x' does not immediately follow the declspec (though
1360 /// ')' happens to be valid anyway).
1361 ///    int (x)
1362 ///
1363 static bool isValidAfterIdentifierInDeclarator(const Token &T) {
1364   return T.is(tok::l_square) || T.is(tok::l_paren) || T.is(tok::r_paren) ||
1365          T.is(tok::semi) || T.is(tok::comma) || T.is(tok::equal) ||
1366          T.is(tok::kw_asm) || T.is(tok::l_brace) || T.is(tok::colon);
1367 }
1368
1369
1370 /// ParseImplicitInt - This method is called when we have an non-typename
1371 /// identifier in a declspec (which normally terminates the decl spec) when
1372 /// the declspec has no type specifier.  In this case, the declspec is either
1373 /// malformed or is "implicit int" (in K&R and C89).
1374 ///
1375 /// This method handles diagnosing this prettily and returns false if the
1376 /// declspec is done being processed.  If it recovers and thinks there may be
1377 /// other pieces of declspec after it, it returns true.
1378 ///
1379 bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
1380                               const ParsedTemplateInfo &TemplateInfo,
1381                               AccessSpecifier AS) {
1382   assert(Tok.is(tok::identifier) && "should have identifier");
1383
1384   SourceLocation Loc = Tok.getLocation();
1385   // If we see an identifier that is not a type name, we normally would
1386   // parse it as the identifer being declared.  However, when a typename
1387   // is typo'd or the definition is not included, this will incorrectly
1388   // parse the typename as the identifier name and fall over misparsing
1389   // later parts of the diagnostic.
1390   //
1391   // As such, we try to do some look-ahead in cases where this would
1392   // otherwise be an "implicit-int" case to see if this is invalid.  For
1393   // example: "static foo_t x = 4;"  In this case, if we parsed foo_t as
1394   // an identifier with implicit int, we'd get a parse error because the
1395   // next token is obviously invalid for a type.  Parse these as a case
1396   // with an invalid type specifier.
1397   assert(!DS.hasTypeSpecifier() && "Type specifier checked above");
1398
1399   // Since we know that this either implicit int (which is rare) or an
1400   // error, we'd do lookahead to try to do better recovery.
1401   if (isValidAfterIdentifierInDeclarator(NextToken())) {
1402     // If this token is valid for implicit int, e.g. "static x = 4", then
1403     // we just avoid eating the identifier, so it will be parsed as the
1404     // identifier in the declarator.
1405     return false;
1406   }
1407
1408   // Otherwise, if we don't consume this token, we are going to emit an
1409   // error anyway.  Try to recover from various common problems.  Check
1410   // to see if this was a reference to a tag name without a tag specified.
1411   // This is a common problem in C (saying 'foo' instead of 'struct foo').
1412   //
1413   // C++ doesn't need this, and isTagName doesn't take SS.
1414   if (SS == 0) {
1415     const char *TagName = 0, *FixitTagName = 0;
1416     tok::TokenKind TagKind = tok::unknown;
1417
1418     switch (Actions.isTagName(*Tok.getIdentifierInfo(), getCurScope())) {
1419       default: break;
1420       case DeclSpec::TST_enum:
1421         TagName="enum"  ; FixitTagName = "enum "  ; TagKind=tok::kw_enum ;break;
1422       case DeclSpec::TST_union:
1423         TagName="union" ; FixitTagName = "union " ;TagKind=tok::kw_union ;break;
1424       case DeclSpec::TST_struct:
1425         TagName="struct"; FixitTagName = "struct ";TagKind=tok::kw_struct;break;
1426       case DeclSpec::TST_class:
1427         TagName="class" ; FixitTagName = "class " ;TagKind=tok::kw_class ;break;
1428     }
1429
1430     if (TagName) {
1431       Diag(Loc, diag::err_use_of_tag_name_without_tag)
1432         << Tok.getIdentifierInfo() << TagName << getLang().CPlusPlus
1433         << FixItHint::CreateInsertion(Tok.getLocation(),FixitTagName);
1434
1435       // Parse this as a tag as if the missing tag were present.
1436       if (TagKind == tok::kw_enum)
1437         ParseEnumSpecifier(Loc, DS, TemplateInfo, AS);
1438       else
1439         ParseClassSpecifier(TagKind, Loc, DS, TemplateInfo, AS);
1440       return true;
1441     }
1442   }
1443
1444   // This is almost certainly an invalid type name. Let the action emit a
1445   // diagnostic and attempt to recover.
1446   ParsedType T;
1447   if (Actions.DiagnoseUnknownTypeName(*Tok.getIdentifierInfo(), Loc,
1448                                       getCurScope(), SS, T)) {
1449     // The action emitted a diagnostic, so we don't have to.
1450     if (T) {
1451       // The action has suggested that the type T could be used. Set that as
1452       // the type in the declaration specifiers, consume the would-be type
1453       // name token, and we're done.
1454       const char *PrevSpec;
1455       unsigned DiagID;
1456       DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, T);
1457       DS.SetRangeEnd(Tok.getLocation());
1458       ConsumeToken();
1459
1460       // There may be other declaration specifiers after this.
1461       return true;
1462     }
1463
1464     // Fall through; the action had no suggestion for us.
1465   } else {
1466     // The action did not emit a diagnostic, so emit one now.
1467     SourceRange R;
1468     if (SS) R = SS->getRange();
1469     Diag(Loc, diag::err_unknown_typename) << Tok.getIdentifierInfo() << R;
1470   }
1471
1472   // Mark this as an error.
1473   const char *PrevSpec;
1474   unsigned DiagID;
1475   DS.SetTypeSpecType(DeclSpec::TST_error, Loc, PrevSpec, DiagID);
1476   DS.SetRangeEnd(Tok.getLocation());
1477   ConsumeToken();
1478
1479   // TODO: Could inject an invalid typedef decl in an enclosing scope to
1480   // avoid rippling error messages on subsequent uses of the same type,
1481   // could be useful if #include was forgotten.
1482   return false;
1483 }
1484
1485 /// \brief Determine the declaration specifier context from the declarator
1486 /// context.
1487 ///
1488 /// \param Context the declarator context, which is one of the
1489 /// Declarator::TheContext enumerator values.
1490 Parser::DeclSpecContext
1491 Parser::getDeclSpecContextFromDeclaratorContext(unsigned Context) {
1492   if (Context == Declarator::MemberContext)
1493     return DSC_class;
1494   if (Context == Declarator::FileContext)
1495     return DSC_top_level;
1496   return DSC_normal;
1497 }
1498
1499 /// ParseAlignArgument - Parse the argument to an alignment-specifier.
1500 ///
1501 /// FIXME: Simply returns an alignof() expression if the argument is a
1502 /// type. Ideally, the type should be propagated directly into Sema.
1503 ///
1504 /// [C1X/C++0x] type-id
1505 /// [C1X]       constant-expression
1506 /// [C++0x]     assignment-expression
1507 ExprResult Parser::ParseAlignArgument(SourceLocation Start) {
1508   if (isTypeIdInParens()) {
1509     EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated);
1510     SourceLocation TypeLoc = Tok.getLocation();
1511     ParsedType Ty = ParseTypeName().get();
1512     SourceRange TypeRange(Start, Tok.getLocation());
1513     return Actions.ActOnUnaryExprOrTypeTraitExpr(TypeLoc, UETT_AlignOf, true,
1514                                                 Ty.getAsOpaquePtr(), TypeRange);
1515   } else
1516     return ParseConstantExpression();
1517 }
1518
1519 /// ParseAlignmentSpecifier - Parse an alignment-specifier, and add the
1520 /// attribute to Attrs.
1521 ///
1522 /// alignment-specifier:
1523 /// [C1X]   '_Alignas' '(' type-id ')'
1524 /// [C1X]   '_Alignas' '(' constant-expression ')'
1525 /// [C++0x] 'alignas' '(' type-id ')'
1526 /// [C++0x] 'alignas' '(' assignment-expression ')'
1527 void Parser::ParseAlignmentSpecifier(ParsedAttributes &Attrs,
1528                                      SourceLocation *endLoc) {
1529   assert((Tok.is(tok::kw_alignas) || Tok.is(tok::kw__Alignas)) &&
1530          "Not an alignment-specifier!");
1531
1532   SourceLocation KWLoc = Tok.getLocation();
1533   ConsumeToken();
1534
1535   BalancedDelimiterTracker T(*this, tok::l_paren);
1536   if (T.expectAndConsume(diag::err_expected_lparen))
1537     return;
1538
1539   ExprResult ArgExpr = ParseAlignArgument(T.getOpenLocation());
1540   if (ArgExpr.isInvalid()) {
1541     SkipUntil(tok::r_paren);
1542     return;
1543   }
1544
1545   T.consumeClose();
1546   if (endLoc)
1547     *endLoc = T.getCloseLocation();
1548
1549   ExprVector ArgExprs(Actions);
1550   ArgExprs.push_back(ArgExpr.release());
1551   Attrs.addNew(PP.getIdentifierInfo("aligned"), KWLoc, 0, KWLoc,
1552                0, T.getOpenLocation(), ArgExprs.take(), 1, false, true);
1553 }
1554
1555 /// ParseDeclarationSpecifiers
1556 ///       declaration-specifiers: [C99 6.7]
1557 ///         storage-class-specifier declaration-specifiers[opt]
1558 ///         type-specifier declaration-specifiers[opt]
1559 /// [C99]   function-specifier declaration-specifiers[opt]
1560 /// [C1X]   alignment-specifier declaration-specifiers[opt]
1561 /// [GNU]   attributes declaration-specifiers[opt]
1562 /// [Clang] '__module_private__' declaration-specifiers[opt]
1563 ///
1564 ///       storage-class-specifier: [C99 6.7.1]
1565 ///         'typedef'
1566 ///         'extern'
1567 ///         'static'
1568 ///         'auto'
1569 ///         'register'
1570 /// [C++]   'mutable'
1571 /// [GNU]   '__thread'
1572 ///       function-specifier: [C99 6.7.4]
1573 /// [C99]   'inline'
1574 /// [C++]   'virtual'
1575 /// [C++]   'explicit'
1576 /// [OpenCL] '__kernel'
1577 ///       'friend': [C++ dcl.friend]
1578 ///       'constexpr': [C++0x dcl.constexpr]
1579
1580 ///
1581 void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
1582                                         const ParsedTemplateInfo &TemplateInfo,
1583                                         AccessSpecifier AS,
1584                                         DeclSpecContext DSContext) {
1585   if (DS.getSourceRange().isInvalid()) {
1586     DS.SetRangeStart(Tok.getLocation());
1587     DS.SetRangeEnd(Tok.getLocation());
1588   }
1589
1590   while (1) {
1591     bool isInvalid = false;
1592     const char *PrevSpec = 0;
1593     unsigned DiagID = 0;
1594
1595     SourceLocation Loc = Tok.getLocation();
1596
1597     switch (Tok.getKind()) {
1598     default:
1599     DoneWithDeclSpec:
1600       // [C++0x] decl-specifier-seq: decl-specifier attribute-specifier-seq[opt]
1601       MaybeParseCXX0XAttributes(DS.getAttributes());
1602
1603       // If this is not a declaration specifier token, we're done reading decl
1604       // specifiers.  First verify that DeclSpec's are consistent.
1605       DS.Finish(Diags, PP);
1606       return;
1607
1608     case tok::code_completion: {
1609       Sema::ParserCompletionContext CCC = Sema::PCC_Namespace;
1610       if (DS.hasTypeSpecifier()) {
1611         bool AllowNonIdentifiers
1612           = (getCurScope()->getFlags() & (Scope::ControlScope |
1613                                           Scope::BlockScope |
1614                                           Scope::TemplateParamScope |
1615                                           Scope::FunctionPrototypeScope |
1616                                           Scope::AtCatchScope)) == 0;
1617         bool AllowNestedNameSpecifiers
1618           = DSContext == DSC_top_level ||
1619             (DSContext == DSC_class && DS.isFriendSpecified());
1620
1621         Actions.CodeCompleteDeclSpec(getCurScope(), DS,
1622                                      AllowNonIdentifiers,
1623                                      AllowNestedNameSpecifiers);
1624         return cutOffParsing();
1625       }
1626
1627       if (getCurScope()->getFnParent() || getCurScope()->getBlockParent())
1628         CCC = Sema::PCC_LocalDeclarationSpecifiers;
1629       else if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate)
1630         CCC = DSContext == DSC_class? Sema::PCC_MemberTemplate
1631                                     : Sema::PCC_Template;
1632       else if (DSContext == DSC_class)
1633         CCC = Sema::PCC_Class;
1634       else if (ObjCImpDecl)
1635         CCC = Sema::PCC_ObjCImplementation;
1636
1637       Actions.CodeCompleteOrdinaryName(getCurScope(), CCC);
1638       return cutOffParsing();
1639     }
1640
1641     case tok::coloncolon: // ::foo::bar
1642       // C++ scope specifier.  Annotate and loop, or bail out on error.
1643       if (TryAnnotateCXXScopeToken(true)) {
1644         if (!DS.hasTypeSpecifier())
1645           DS.SetTypeSpecError();
1646         goto DoneWithDeclSpec;
1647       }
1648       if (Tok.is(tok::coloncolon)) // ::new or ::delete
1649         goto DoneWithDeclSpec;
1650       continue;
1651
1652     case tok::annot_cxxscope: {
1653       if (DS.hasTypeSpecifier())
1654         goto DoneWithDeclSpec;
1655
1656       CXXScopeSpec SS;
1657       Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
1658                                                    Tok.getAnnotationRange(),
1659                                                    SS);
1660
1661       // We are looking for a qualified typename.
1662       Token Next = NextToken();
1663       if (Next.is(tok::annot_template_id) &&
1664           static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue())
1665             ->Kind == TNK_Type_template) {
1666         // We have a qualified template-id, e.g., N::A<int>
1667
1668         // C++ [class.qual]p2:
1669         //   In a lookup in which the constructor is an acceptable lookup
1670         //   result and the nested-name-specifier nominates a class C:
1671         //
1672         //     - if the name specified after the
1673         //       nested-name-specifier, when looked up in C, is the
1674         //       injected-class-name of C (Clause 9), or
1675         //
1676         //     - if the name specified after the nested-name-specifier
1677         //       is the same as the identifier or the
1678         //       simple-template-id's template-name in the last
1679         //       component of the nested-name-specifier,
1680         //
1681         //   the name is instead considered to name the constructor of
1682         //   class C.
1683         //
1684         // Thus, if the template-name is actually the constructor
1685         // name, then the code is ill-formed; this interpretation is
1686         // reinforced by the NAD status of core issue 635.
1687         TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Next);
1688         if ((DSContext == DSC_top_level ||
1689              (DSContext == DSC_class && DS.isFriendSpecified())) &&
1690             TemplateId->Name &&
1691             Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
1692           if (isConstructorDeclarator()) {
1693             // The user meant this to be an out-of-line constructor
1694             // definition, but template arguments are not allowed
1695             // there.  Just allow this as a constructor; we'll
1696             // complain about it later.
1697             goto DoneWithDeclSpec;
1698           }
1699
1700           // The user meant this to name a type, but it actually names
1701           // a constructor with some extraneous template
1702           // arguments. Complain, then parse it as a type as the user
1703           // intended.
1704           Diag(TemplateId->TemplateNameLoc,
1705                diag::err_out_of_line_template_id_names_constructor)
1706             << TemplateId->Name;
1707         }
1708
1709         DS.getTypeSpecScope() = SS;
1710         ConsumeToken(); // The C++ scope.
1711         assert(Tok.is(tok::annot_template_id) &&
1712                "ParseOptionalCXXScopeSpecifier not working");
1713         AnnotateTemplateIdTokenAsType();
1714         continue;
1715       }
1716
1717       if (Next.is(tok::annot_typename)) {
1718         DS.getTypeSpecScope() = SS;
1719         ConsumeToken(); // The C++ scope.
1720         if (Tok.getAnnotationValue()) {
1721           ParsedType T = getTypeAnnotation(Tok);
1722           isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename,
1723                                          Tok.getAnnotationEndLoc(),
1724                                          PrevSpec, DiagID, T);
1725         }
1726         else
1727           DS.SetTypeSpecError();
1728         DS.SetRangeEnd(Tok.getAnnotationEndLoc());
1729         ConsumeToken(); // The typename
1730       }
1731
1732       if (Next.isNot(tok::identifier))
1733         goto DoneWithDeclSpec;
1734
1735       // If we're in a context where the identifier could be a class name,
1736       // check whether this is a constructor declaration.
1737       if ((DSContext == DSC_top_level ||
1738            (DSContext == DSC_class && DS.isFriendSpecified())) &&
1739           Actions.isCurrentClassName(*Next.getIdentifierInfo(), getCurScope(),
1740                                      &SS)) {
1741         if (isConstructorDeclarator())
1742           goto DoneWithDeclSpec;
1743
1744         // As noted in C++ [class.qual]p2 (cited above), when the name
1745         // of the class is qualified in a context where it could name
1746         // a constructor, its a constructor name. However, we've
1747         // looked at the declarator, and the user probably meant this
1748         // to be a type. Complain that it isn't supposed to be treated
1749         // as a type, then proceed to parse it as a type.
1750         Diag(Next.getLocation(), diag::err_out_of_line_type_names_constructor)
1751           << Next.getIdentifierInfo();
1752       }
1753
1754       ParsedType TypeRep = Actions.getTypeName(*Next.getIdentifierInfo(),
1755                                                Next.getLocation(),
1756                                                getCurScope(), &SS,
1757                                                false, false, ParsedType(),
1758                                                /*NonTrivialSourceInfo=*/true);
1759
1760       // If the referenced identifier is not a type, then this declspec is
1761       // erroneous: We already checked about that it has no type specifier, and
1762       // C++ doesn't have implicit int.  Diagnose it as a typo w.r.t. to the
1763       // typename.
1764       if (TypeRep == 0) {
1765         ConsumeToken();   // Eat the scope spec so the identifier is current.
1766         if (ParseImplicitInt(DS, &SS, TemplateInfo, AS)) continue;
1767         goto DoneWithDeclSpec;
1768       }
1769
1770       DS.getTypeSpecScope() = SS;
1771       ConsumeToken(); // The C++ scope.
1772
1773       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
1774                                      DiagID, TypeRep);
1775       if (isInvalid)
1776         break;
1777
1778       DS.SetRangeEnd(Tok.getLocation());
1779       ConsumeToken(); // The typename.
1780
1781       continue;
1782     }
1783
1784     case tok::annot_typename: {
1785       if (Tok.getAnnotationValue()) {
1786         ParsedType T = getTypeAnnotation(Tok);
1787         isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
1788                                        DiagID, T);
1789       } else
1790         DS.SetTypeSpecError();
1791
1792       if (isInvalid)
1793         break;
1794
1795       DS.SetRangeEnd(Tok.getAnnotationEndLoc());
1796       ConsumeToken(); // The typename
1797
1798       // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
1799       // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
1800       // Objective-C interface.
1801       if (Tok.is(tok::less) && getLang().ObjC1)
1802         ParseObjCProtocolQualifiers(DS);
1803
1804       continue;
1805     }
1806
1807     case tok::kw___is_signed:
1808       // GNU libstdc++ 4.4 uses __is_signed as an identifier, but Clang
1809       // typically treats it as a trait. If we see __is_signed as it appears
1810       // in libstdc++, e.g.,
1811       //
1812       //   static const bool __is_signed;
1813       //
1814       // then treat __is_signed as an identifier rather than as a keyword.
1815       if (DS.getTypeSpecType() == TST_bool &&
1816           DS.getTypeQualifiers() == DeclSpec::TQ_const &&
1817           DS.getStorageClassSpec() == DeclSpec::SCS_static) {
1818         Tok.getIdentifierInfo()->RevertTokenIDToIdentifier();
1819         Tok.setKind(tok::identifier);
1820       }
1821
1822       // We're done with the declaration-specifiers.
1823       goto DoneWithDeclSpec;
1824
1825       // typedef-name
1826     case tok::identifier: {
1827       // In C++, check to see if this is a scope specifier like foo::bar::, if
1828       // so handle it as such.  This is important for ctor parsing.
1829       if (getLang().CPlusPlus) {
1830         if (TryAnnotateCXXScopeToken(true)) {
1831           if (!DS.hasTypeSpecifier())
1832             DS.SetTypeSpecError();
1833           goto DoneWithDeclSpec;
1834         }
1835         if (!Tok.is(tok::identifier))
1836           continue;
1837       }
1838
1839       // This identifier can only be a typedef name if we haven't already seen
1840       // a type-specifier.  Without this check we misparse:
1841       //  typedef int X; struct Y { short X; };  as 'short int'.
1842       if (DS.hasTypeSpecifier())
1843         goto DoneWithDeclSpec;
1844
1845       // Check for need to substitute AltiVec keyword tokens.
1846       if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid))
1847         break;
1848
1849       // It has to be available as a typedef too!
1850       ParsedType TypeRep =
1851         Actions.getTypeName(*Tok.getIdentifierInfo(),
1852                             Tok.getLocation(), getCurScope());
1853
1854       // If this is not a typedef name, don't parse it as part of the declspec,
1855       // it must be an implicit int or an error.
1856       if (!TypeRep) {
1857         if (ParseImplicitInt(DS, 0, TemplateInfo, AS)) continue;
1858         goto DoneWithDeclSpec;
1859       }
1860
1861       // If we're in a context where the identifier could be a class name,
1862       // check whether this is a constructor declaration.
1863       if (getLang().CPlusPlus && DSContext == DSC_class &&
1864           Actions.isCurrentClassName(*Tok.getIdentifierInfo(), getCurScope()) &&
1865           isConstructorDeclarator())
1866         goto DoneWithDeclSpec;
1867
1868       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
1869                                      DiagID, TypeRep);
1870       if (isInvalid)
1871         break;
1872
1873       DS.SetRangeEnd(Tok.getLocation());
1874       ConsumeToken(); // The identifier
1875
1876       // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
1877       // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
1878       // Objective-C interface.
1879       if (Tok.is(tok::less) && getLang().ObjC1)
1880         ParseObjCProtocolQualifiers(DS);
1881
1882       // Need to support trailing type qualifiers (e.g. "id<p> const").
1883       // If a type specifier follows, it will be diagnosed elsewhere.
1884       continue;
1885     }
1886
1887       // type-name
1888     case tok::annot_template_id: {
1889       TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
1890       if (TemplateId->Kind != TNK_Type_template) {
1891         // This template-id does not refer to a type name, so we're
1892         // done with the type-specifiers.
1893         goto DoneWithDeclSpec;
1894       }
1895
1896       // If we're in a context where the template-id could be a
1897       // constructor name or specialization, check whether this is a
1898       // constructor declaration.
1899       if (getLang().CPlusPlus && DSContext == DSC_class &&
1900           Actions.isCurrentClassName(*TemplateId->Name, getCurScope()) &&
1901           isConstructorDeclarator())
1902         goto DoneWithDeclSpec;
1903
1904       // Turn the template-id annotation token into a type annotation
1905       // token, then try again to parse it as a type-specifier.
1906       AnnotateTemplateIdTokenAsType();
1907       continue;
1908     }
1909
1910     // GNU attributes support.
1911     case tok::kw___attribute:
1912       ParseGNUAttributes(DS.getAttributes());
1913       continue;
1914
1915     // Microsoft declspec support.
1916     case tok::kw___declspec:
1917       ParseMicrosoftDeclSpec(DS.getAttributes());
1918       continue;
1919
1920     // Microsoft single token adornments.
1921     case tok::kw___forceinline:
1922       // FIXME: Add handling here!
1923       break;
1924
1925     case tok::kw___ptr64:
1926     case tok::kw___ptr32:
1927     case tok::kw___w64:
1928     case tok::kw___cdecl:
1929     case tok::kw___stdcall:
1930     case tok::kw___fastcall:
1931     case tok::kw___thiscall:
1932     case tok::kw___unaligned:
1933       ParseMicrosoftTypeAttributes(DS.getAttributes());
1934       continue;
1935
1936     // Borland single token adornments.
1937     case tok::kw___pascal:
1938       ParseBorlandTypeAttributes(DS.getAttributes());
1939       continue;
1940
1941     // OpenCL single token adornments.
1942     case tok::kw___kernel:
1943       ParseOpenCLAttributes(DS.getAttributes());
1944       continue;
1945
1946     // storage-class-specifier
1947     case tok::kw_typedef:
1948       isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_typedef, Loc,
1949                                          PrevSpec, DiagID);
1950       break;
1951     case tok::kw_extern:
1952       if (DS.isThreadSpecified())
1953         Diag(Tok, diag::ext_thread_before) << "extern";
1954       isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_extern, Loc,
1955                                          PrevSpec, DiagID);
1956       break;
1957     case tok::kw___private_extern__:
1958       isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_private_extern,
1959                                          Loc, PrevSpec, DiagID);
1960       break;
1961     case tok::kw_static:
1962       if (DS.isThreadSpecified())
1963         Diag(Tok, diag::ext_thread_before) << "static";
1964       isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_static, Loc,
1965                                          PrevSpec, DiagID);
1966       break;
1967     case tok::kw_auto:
1968       if (getLang().CPlusPlus0x) {
1969         if (isKnownToBeTypeSpecifier(GetLookAheadToken(1))) {
1970           isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
1971                                              PrevSpec, DiagID);
1972           if (!isInvalid)
1973             Diag(Tok, diag::ext_auto_storage_class)
1974               << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
1975         } else
1976           isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec,
1977                                          DiagID);
1978       } else
1979         isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
1980                                            PrevSpec, DiagID);
1981       break;
1982     case tok::kw_register:
1983       isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_register, Loc,
1984                                          PrevSpec, DiagID);
1985       break;
1986     case tok::kw_mutable:
1987       isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_mutable, Loc,
1988                                          PrevSpec, DiagID);
1989       break;
1990     case tok::kw___thread:
1991       isInvalid = DS.SetStorageClassSpecThread(Loc, PrevSpec, DiagID);
1992       break;
1993
1994     // function-specifier
1995     case tok::kw_inline:
1996       isInvalid = DS.SetFunctionSpecInline(Loc, PrevSpec, DiagID);
1997       break;
1998     case tok::kw_virtual:
1999       isInvalid = DS.SetFunctionSpecVirtual(Loc, PrevSpec, DiagID);
2000       break;
2001     case tok::kw_explicit:
2002       isInvalid = DS.SetFunctionSpecExplicit(Loc, PrevSpec, DiagID);
2003       break;
2004
2005     // alignment-specifier
2006     case tok::kw__Alignas:
2007       if (!getLang().C1X)
2008         Diag(Tok, diag::ext_c1x_alignas);
2009       ParseAlignmentSpecifier(DS.getAttributes());
2010       continue;
2011
2012     // friend
2013     case tok::kw_friend:
2014       if (DSContext == DSC_class)
2015         isInvalid = DS.SetFriendSpec(Loc, PrevSpec, DiagID);
2016       else {
2017         PrevSpec = ""; // not actually used by the diagnostic
2018         DiagID = diag::err_friend_invalid_in_context;
2019         isInvalid = true;
2020       }
2021       break;
2022
2023     // Modules
2024     case tok::kw___module_private__:
2025       isInvalid = DS.setModulePrivateSpec(Loc, PrevSpec, DiagID);
2026       break;
2027
2028     // constexpr
2029     case tok::kw_constexpr:
2030       isInvalid = DS.SetConstexprSpec(Loc, PrevSpec, DiagID);
2031       break;
2032
2033     // type-specifier
2034     case tok::kw_short:
2035       isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec,
2036                                       DiagID);
2037       break;
2038     case tok::kw_long:
2039       if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
2040         isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec,
2041                                         DiagID);
2042       else
2043         isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
2044                                         DiagID);
2045       break;
2046     case tok::kw___int64:
2047         isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
2048                                         DiagID);
2049       break;
2050     case tok::kw_signed:
2051       isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec,
2052                                      DiagID);
2053       break;
2054     case tok::kw_unsigned:
2055       isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec,
2056                                      DiagID);
2057       break;
2058     case tok::kw__Complex:
2059       isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec,
2060                                         DiagID);
2061       break;
2062     case tok::kw__Imaginary:
2063       isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec,
2064                                         DiagID);
2065       break;
2066     case tok::kw_void:
2067       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec,
2068                                      DiagID);
2069       break;
2070     case tok::kw_char:
2071       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec,
2072                                      DiagID);
2073       break;
2074     case tok::kw_int:
2075       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec,
2076                                      DiagID);
2077       break;
2078      case tok::kw_half:
2079        isInvalid = DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec,
2080                                       DiagID);
2081        break;
2082     case tok::kw_float:
2083       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec,
2084                                      DiagID);
2085       break;
2086     case tok::kw_double:
2087       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec,
2088                                      DiagID);
2089       break;
2090     case tok::kw_wchar_t:
2091       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec,
2092                                      DiagID);
2093       break;
2094     case tok::kw_char16_t:
2095       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec,
2096                                      DiagID);
2097       break;
2098     case tok::kw_char32_t:
2099       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec,
2100                                      DiagID);
2101       break;
2102     case tok::kw_bool:
2103     case tok::kw__Bool:
2104       if (Tok.is(tok::kw_bool) &&
2105           DS.getTypeSpecType() != DeclSpec::TST_unspecified &&
2106           DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
2107         PrevSpec = ""; // Not used by the diagnostic.
2108         DiagID = diag::err_bool_redeclaration;
2109         // For better error recovery.
2110         Tok.setKind(tok::identifier);
2111         isInvalid = true;
2112       } else {
2113         isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec,
2114                                        DiagID);
2115       }
2116       break;
2117     case tok::kw__Decimal32:
2118       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec,
2119                                      DiagID);
2120       break;
2121     case tok::kw__Decimal64:
2122       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec,
2123                                      DiagID);
2124       break;
2125     case tok::kw__Decimal128:
2126       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec,
2127                                      DiagID);
2128       break;
2129     case tok::kw___vector:
2130       isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
2131       break;
2132     case tok::kw___pixel:
2133       isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID);
2134       break;
2135     case tok::kw___unknown_anytype:
2136       isInvalid = DS.SetTypeSpecType(TST_unknown_anytype, Loc,
2137                                      PrevSpec, DiagID);
2138       break;
2139
2140     // class-specifier:
2141     case tok::kw_class:
2142     case tok::kw_struct:
2143     case tok::kw_union: {
2144       tok::TokenKind Kind = Tok.getKind();
2145       ConsumeToken();
2146       ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS);
2147       continue;
2148     }
2149
2150     // enum-specifier:
2151     case tok::kw_enum:
2152       ConsumeToken();
2153       ParseEnumSpecifier(Loc, DS, TemplateInfo, AS);
2154       continue;
2155
2156     // cv-qualifier:
2157     case tok::kw_const:
2158       isInvalid = DS.SetTypeQual(DeclSpec::TQ_const, Loc, PrevSpec, DiagID,
2159                                  getLang());
2160       break;
2161     case tok::kw_volatile:
2162       isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
2163                                  getLang());
2164       break;
2165     case tok::kw_restrict:
2166       isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
2167                                  getLang());
2168       break;
2169
2170     // C++ typename-specifier:
2171     case tok::kw_typename:
2172       if (TryAnnotateTypeOrScopeToken()) {
2173         DS.SetTypeSpecError();
2174         goto DoneWithDeclSpec;
2175       }
2176       if (!Tok.is(tok::kw_typename))
2177         continue;
2178       break;
2179
2180     // GNU typeof support.
2181     case tok::kw_typeof:
2182       ParseTypeofSpecifier(DS);
2183       continue;
2184
2185     case tok::kw_decltype:
2186       ParseDecltypeSpecifier(DS);
2187       continue;
2188
2189     case tok::kw___underlying_type:
2190       ParseUnderlyingTypeSpecifier(DS);
2191       continue;
2192
2193     case tok::kw__Atomic:
2194       ParseAtomicSpecifier(DS);
2195       continue;
2196
2197     // OpenCL qualifiers:
2198     case tok::kw_private:
2199       if (!getLang().OpenCL)
2200         goto DoneWithDeclSpec;
2201     case tok::kw___private:
2202     case tok::kw___global:
2203     case tok::kw___local:
2204     case tok::kw___constant:
2205     case tok::kw___read_only:
2206     case tok::kw___write_only:
2207     case tok::kw___read_write:
2208       ParseOpenCLQualifiers(DS);
2209       break;
2210
2211     case tok::less:
2212       // GCC ObjC supports types like "<SomeProtocol>" as a synonym for
2213       // "id<SomeProtocol>".  This is hopelessly old fashioned and dangerous,
2214       // but we support it.
2215       if (DS.hasTypeSpecifier() || !getLang().ObjC1)
2216         goto DoneWithDeclSpec;
2217
2218       if (!ParseObjCProtocolQualifiers(DS))
2219         Diag(Loc, diag::warn_objc_protocol_qualifier_missing_id)
2220           << FixItHint::CreateInsertion(Loc, "id")
2221           << SourceRange(Loc, DS.getSourceRange().getEnd());
2222
2223       // Need to support trailing type qualifiers (e.g. "id<p> const").
2224       // If a type specifier follows, it will be diagnosed elsewhere.
2225       continue;
2226     }
2227     // If the specifier wasn't legal, issue a diagnostic.
2228     if (isInvalid) {
2229       assert(PrevSpec && "Method did not return previous specifier!");
2230       assert(DiagID);
2231
2232       if (DiagID == diag::ext_duplicate_declspec)
2233         Diag(Tok, DiagID)
2234           << PrevSpec << FixItHint::CreateRemoval(Tok.getLocation());
2235       else
2236         Diag(Tok, DiagID) << PrevSpec;
2237     }
2238
2239     DS.SetRangeEnd(Tok.getLocation());
2240     if (DiagID != diag::err_bool_redeclaration)
2241       ConsumeToken();
2242   }
2243 }
2244
2245 /// ParseOptionalTypeSpecifier - Try to parse a single type-specifier. We
2246 /// primarily follow the C++ grammar with additions for C99 and GNU,
2247 /// which together subsume the C grammar. Note that the C++
2248 /// type-specifier also includes the C type-qualifier (for const,
2249 /// volatile, and C99 restrict). Returns true if a type-specifier was
2250 /// found (and parsed), false otherwise.
2251 ///
2252 ///       type-specifier: [C++ 7.1.5]
2253 ///         simple-type-specifier
2254 ///         class-specifier
2255 ///         enum-specifier
2256 ///         elaborated-type-specifier  [TODO]
2257 ///         cv-qualifier
2258 ///
2259 ///       cv-qualifier: [C++ 7.1.5.1]
2260 ///         'const'
2261 ///         'volatile'
2262 /// [C99]   'restrict'
2263 ///
2264 ///       simple-type-specifier: [ C++ 7.1.5.2]
2265 ///         '::'[opt] nested-name-specifier[opt] type-name [TODO]
2266 ///         '::'[opt] nested-name-specifier 'template' template-id [TODO]
2267 ///         'char'
2268 ///         'wchar_t'
2269 ///         'bool'
2270 ///         'short'
2271 ///         'int'
2272 ///         'long'
2273 ///         'signed'
2274 ///         'unsigned'
2275 ///         'float'
2276 ///         'double'
2277 ///         'void'
2278 /// [C99]   '_Bool'
2279 /// [C99]   '_Complex'
2280 /// [C99]   '_Imaginary'  // Removed in TC2?
2281 /// [GNU]   '_Decimal32'
2282 /// [GNU]   '_Decimal64'
2283 /// [GNU]   '_Decimal128'
2284 /// [GNU]   typeof-specifier
2285 /// [OBJC]  class-name objc-protocol-refs[opt]    [TODO]
2286 /// [OBJC]  typedef-name objc-protocol-refs[opt]  [TODO]
2287 /// [C++0x] 'decltype' ( expression )
2288 /// [AltiVec] '__vector'
2289 bool Parser::ParseOptionalTypeSpecifier(DeclSpec &DS, bool& isInvalid,
2290                                         const char *&PrevSpec,
2291                                         unsigned &DiagID,
2292                                         const ParsedTemplateInfo &TemplateInfo,
2293                                         bool SuppressDeclarations) {
2294   SourceLocation Loc = Tok.getLocation();
2295
2296   switch (Tok.getKind()) {
2297   case tok::identifier:   // foo::bar
2298     // If we already have a type specifier, this identifier is not a type.
2299     if (DS.getTypeSpecType() != DeclSpec::TST_unspecified ||
2300         DS.getTypeSpecWidth() != DeclSpec::TSW_unspecified ||
2301         DS.getTypeSpecSign() != DeclSpec::TSS_unspecified)
2302       return false;
2303     // Check for need to substitute AltiVec keyword tokens.
2304     if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid))
2305       break;
2306     // Fall through.
2307   case tok::kw_typename:  // typename foo::bar
2308     // Annotate typenames and C++ scope specifiers.  If we get one, just
2309     // recurse to handle whatever we get.
2310     if (TryAnnotateTypeOrScopeToken(/*EnteringContext=*/false,
2311                                     /*NeedType=*/true))
2312       return true;
2313     if (Tok.is(tok::identifier))
2314       return false;
2315     return ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, DiagID,
2316                                       TemplateInfo, SuppressDeclarations);
2317   case tok::coloncolon:   // ::foo::bar
2318     if (NextToken().is(tok::kw_new) ||    // ::new
2319         NextToken().is(tok::kw_delete))   // ::delete
2320       return false;
2321
2322     // Annotate typenames and C++ scope specifiers.  If we get one, just
2323     // recurse to handle whatever we get.
2324     if (TryAnnotateTypeOrScopeToken(/*EnteringContext=*/false,
2325                                     /*NeedType=*/true))
2326       return true;
2327     return ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, DiagID,
2328                                       TemplateInfo, SuppressDeclarations);
2329
2330   // simple-type-specifier:
2331   case tok::annot_typename: {
2332     if (ParsedType T = getTypeAnnotation(Tok)) {
2333       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename,
2334                                      Tok.getAnnotationEndLoc(), PrevSpec,
2335                                      DiagID, T);
2336     } else
2337       DS.SetTypeSpecError();
2338     DS.SetRangeEnd(Tok.getAnnotationEndLoc());
2339     ConsumeToken(); // The typename
2340
2341     // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
2342     // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
2343     // Objective-C interface.  If we don't have Objective-C or a '<', this is
2344     // just a normal reference to a typedef name.
2345     if (Tok.is(tok::less) && getLang().ObjC1)
2346       ParseObjCProtocolQualifiers(DS);
2347
2348     return true;
2349   }
2350
2351   case tok::kw_short:
2352     isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID);
2353     break;
2354   case tok::kw_long:
2355     if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
2356       isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec,
2357                                       DiagID);
2358     else
2359       isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
2360                                       DiagID);
2361     break;
2362   case tok::kw___int64:
2363       isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
2364                                       DiagID);
2365     break;
2366   case tok::kw_signed:
2367     isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID);
2368     break;
2369   case tok::kw_unsigned:
2370     isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec,
2371                                    DiagID);
2372     break;
2373   case tok::kw__Complex:
2374     isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec,
2375                                       DiagID);
2376     break;
2377   case tok::kw__Imaginary:
2378     isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec,
2379                                       DiagID);
2380     break;
2381   case tok::kw_void:
2382     isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID);
2383     break;
2384   case tok::kw_char:
2385     isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID);
2386     break;
2387   case tok::kw_int:
2388     isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID);
2389     break;
2390   case tok::kw_half:
2391     isInvalid = DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID);
2392     break;
2393   case tok::kw_float:
2394     isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID);
2395     break;
2396   case tok::kw_double:
2397     isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID);
2398     break;
2399   case tok::kw_wchar_t:
2400     isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID);
2401     break;
2402   case tok::kw_char16_t:
2403     isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID);
2404     break;
2405   case tok::kw_char32_t:
2406     isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID);
2407     break;
2408   case tok::kw_bool:
2409   case tok::kw__Bool:
2410     isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID);
2411     break;
2412   case tok::kw__Decimal32:
2413     isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec,
2414                                    DiagID);
2415     break;
2416   case tok::kw__Decimal64:
2417     isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec,
2418                                    DiagID);
2419     break;
2420   case tok::kw__Decimal128:
2421     isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec,
2422                                    DiagID);
2423     break;
2424   case tok::kw___vector:
2425     isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
2426     break;
2427   case tok::kw___pixel:
2428     isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID);
2429     break;
2430
2431   // class-specifier:
2432   case tok::kw_class:
2433   case tok::kw_struct:
2434   case tok::kw_union: {
2435     tok::TokenKind Kind = Tok.getKind();
2436     ConsumeToken();
2437     ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS_none,
2438                         SuppressDeclarations);
2439     return true;
2440   }
2441
2442   // enum-specifier:
2443   case tok::kw_enum:
2444     ConsumeToken();
2445     ParseEnumSpecifier(Loc, DS, TemplateInfo, AS_none);
2446     return true;
2447
2448   // cv-qualifier:
2449   case tok::kw_const:
2450     isInvalid = DS.SetTypeQual(DeclSpec::TQ_const   , Loc, PrevSpec,
2451                                DiagID, getLang());
2452     break;
2453   case tok::kw_volatile:
2454     isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec,
2455                                DiagID, getLang());
2456     break;
2457   case tok::kw_restrict:
2458     isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec,
2459                                DiagID, getLang());
2460     break;
2461
2462   // GNU typeof support.
2463   case tok::kw_typeof:
2464     ParseTypeofSpecifier(DS);
2465     return true;
2466
2467   // C++0x decltype support.
2468   case tok::kw_decltype:
2469     ParseDecltypeSpecifier(DS);
2470     return true;
2471
2472   // C++0x type traits support.
2473   case tok::kw___underlying_type:
2474     ParseUnderlyingTypeSpecifier(DS);
2475     return true;
2476
2477   case tok::kw__Atomic:
2478     ParseAtomicSpecifier(DS);
2479     return true;
2480
2481   // OpenCL qualifiers:
2482   case tok::kw_private:
2483     if (!getLang().OpenCL)
2484       return false;
2485   case tok::kw___private:
2486   case tok::kw___global:
2487   case tok::kw___local:
2488   case tok::kw___constant:
2489   case tok::kw___read_only:
2490   case tok::kw___write_only:
2491   case tok::kw___read_write:
2492     ParseOpenCLQualifiers(DS);
2493     break;
2494
2495   // C++0x auto support.
2496   case tok::kw_auto:
2497     // This is only called in situations where a storage-class specifier is
2498     // illegal, so we can assume an auto type specifier was intended even in
2499     // C++98. In C++98 mode, DeclSpec::Finish will produce an appropriate
2500     // extension diagnostic.
2501     if (!getLang().CPlusPlus)
2502       return false;
2503
2504     isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec, DiagID);
2505     break;
2506
2507   case tok::kw___ptr64:
2508   case tok::kw___ptr32:
2509   case tok::kw___w64:
2510   case tok::kw___cdecl:
2511   case tok::kw___stdcall:
2512   case tok::kw___fastcall:
2513   case tok::kw___thiscall:
2514   case tok::kw___unaligned:
2515     ParseMicrosoftTypeAttributes(DS.getAttributes());
2516     return true;
2517
2518   case tok::kw___pascal:
2519     ParseBorlandTypeAttributes(DS.getAttributes());
2520     return true;
2521
2522   default:
2523     // Not a type-specifier; do nothing.
2524     return false;
2525   }
2526
2527   // If the specifier combination wasn't legal, issue a diagnostic.
2528   if (isInvalid) {
2529     assert(PrevSpec && "Method did not return previous specifier!");
2530     // Pick between error or extwarn.
2531     Diag(Tok, DiagID) << PrevSpec;
2532   }
2533   DS.SetRangeEnd(Tok.getLocation());
2534   ConsumeToken(); // whatever we parsed above.
2535   return true;
2536 }
2537
2538 /// ParseStructDeclaration - Parse a struct declaration without the terminating
2539 /// semicolon.
2540 ///
2541 ///       struct-declaration:
2542 ///         specifier-qualifier-list struct-declarator-list
2543 /// [GNU]   __extension__ struct-declaration
2544 /// [GNU]   specifier-qualifier-list
2545 ///       struct-declarator-list:
2546 ///         struct-declarator
2547 ///         struct-declarator-list ',' struct-declarator
2548 /// [GNU]   struct-declarator-list ',' attributes[opt] struct-declarator
2549 ///       struct-declarator:
2550 ///         declarator
2551 /// [GNU]   declarator attributes[opt]
2552 ///         declarator[opt] ':' constant-expression
2553 /// [GNU]   declarator[opt] ':' constant-expression attributes[opt]
2554 ///
2555 void Parser::
2556 ParseStructDeclaration(DeclSpec &DS, FieldCallback &Fields) {
2557
2558   if (Tok.is(tok::kw___extension__)) {
2559     // __extension__ silences extension warnings in the subexpression.
2560     ExtensionRAIIObject O(Diags);  // Use RAII to do this.
2561     ConsumeToken();
2562     return ParseStructDeclaration(DS, Fields);
2563   }
2564
2565   // Parse the common specifier-qualifiers-list piece.
2566   ParseSpecifierQualifierList(DS);
2567
2568   // If there are no declarators, this is a free-standing declaration
2569   // specifier. Let the actions module cope with it.
2570   if (Tok.is(tok::semi)) {
2571     Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none, DS);
2572     return;
2573   }
2574
2575   // Read struct-declarators until we find the semicolon.
2576   bool FirstDeclarator = true;
2577   while (1) {
2578     ParsingDeclRAIIObject PD(*this);
2579     FieldDeclarator DeclaratorInfo(DS);
2580
2581     // Attributes are only allowed here on successive declarators.
2582     if (!FirstDeclarator)
2583       MaybeParseGNUAttributes(DeclaratorInfo.D);
2584
2585     /// struct-declarator: declarator
2586     /// struct-declarator: declarator[opt] ':' constant-expression
2587     if (Tok.isNot(tok::colon)) {
2588       // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
2589       ColonProtectionRAIIObject X(*this);
2590       ParseDeclarator(DeclaratorInfo.D);
2591     }
2592
2593     if (Tok.is(tok::colon)) {
2594       ConsumeToken();
2595       ExprResult Res(ParseConstantExpression());
2596       if (Res.isInvalid())
2597         SkipUntil(tok::semi, true, true);
2598       else
2599         DeclaratorInfo.BitfieldSize = Res.release();
2600     }
2601
2602     // If attributes exist after the declarator, parse them.
2603     MaybeParseGNUAttributes(DeclaratorInfo.D);
2604
2605     // We're done with this declarator;  invoke the callback.
2606     Decl *D = Fields.invoke(DeclaratorInfo);
2607     PD.complete(D);
2608
2609     // If we don't have a comma, it is either the end of the list (a ';')
2610     // or an error, bail out.
2611     if (Tok.isNot(tok::comma))
2612       return;
2613
2614     // Consume the comma.
2615     ConsumeToken();
2616
2617     FirstDeclarator = false;
2618   }
2619 }
2620
2621 /// ParseStructUnionBody
2622 ///       struct-contents:
2623 ///         struct-declaration-list
2624 /// [EXT]   empty
2625 /// [GNU]   "struct-declaration-list" without terminatoring ';'
2626 ///       struct-declaration-list:
2627 ///         struct-declaration
2628 ///         struct-declaration-list struct-declaration
2629 /// [OBC]   '@' 'defs' '(' class-name ')'
2630 ///
2631 void Parser::ParseStructUnionBody(SourceLocation RecordLoc,
2632                                   unsigned TagType, Decl *TagDecl) {
2633   PrettyDeclStackTraceEntry CrashInfo(Actions, TagDecl, RecordLoc,
2634                                       "parsing struct/union body");
2635
2636   BalancedDelimiterTracker T(*this, tok::l_brace);
2637   if (T.consumeOpen())
2638     return;
2639
2640   ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope);
2641   Actions.ActOnTagStartDefinition(getCurScope(), TagDecl);
2642
2643   // Empty structs are an extension in C (C99 6.7.2.1p7), but are allowed in
2644   // C++.
2645   if (Tok.is(tok::r_brace) && !getLang().CPlusPlus)
2646     Diag(Tok, diag::ext_empty_struct_union)
2647       << (TagType == TST_union);
2648
2649   SmallVector<Decl *, 32> FieldDecls;
2650
2651   // While we still have something to read, read the declarations in the struct.
2652   while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
2653     // Each iteration of this loop reads one struct-declaration.
2654
2655     // Check for extraneous top-level semicolon.
2656     if (Tok.is(tok::semi)) {
2657       Diag(Tok, diag::ext_extra_struct_semi)
2658         << DeclSpec::getSpecifierName((DeclSpec::TST)TagType)
2659         << FixItHint::CreateRemoval(Tok.getLocation());
2660       ConsumeToken();
2661       continue;
2662     }
2663
2664     // Parse all the comma separated declarators.
2665     DeclSpec DS(AttrFactory);
2666
2667     if (!Tok.is(tok::at)) {
2668       struct CFieldCallback : FieldCallback {
2669         Parser &P;
2670         Decl *TagDecl;
2671         SmallVectorImpl<Decl *> &FieldDecls;
2672
2673         CFieldCallback(Parser &P, Decl *TagDecl,
2674                        SmallVectorImpl<Decl *> &FieldDecls) :
2675           P(P), TagDecl(TagDecl), FieldDecls(FieldDecls) {}
2676
2677         virtual Decl *invoke(FieldDeclarator &FD) {
2678           // Install the declarator into the current TagDecl.
2679           Decl *Field = P.Actions.ActOnField(P.getCurScope(), TagDecl,
2680                               FD.D.getDeclSpec().getSourceRange().getBegin(),
2681                                                  FD.D, FD.BitfieldSize);
2682           FieldDecls.push_back(Field);
2683           return Field;
2684         }
2685       } Callback(*this, TagDecl, FieldDecls);
2686
2687       ParseStructDeclaration(DS, Callback);
2688     } else { // Handle @defs
2689       ConsumeToken();
2690       if (!Tok.isObjCAtKeyword(tok::objc_defs)) {
2691         Diag(Tok, diag::err_unexpected_at);
2692         SkipUntil(tok::semi, true);
2693         continue;
2694       }
2695       ConsumeToken();
2696       ExpectAndConsume(tok::l_paren, diag::err_expected_lparen);
2697       if (!Tok.is(tok::identifier)) {
2698         Diag(Tok, diag::err_expected_ident);
2699         SkipUntil(tok::semi, true);
2700         continue;
2701       }
2702       SmallVector<Decl *, 16> Fields;
2703       Actions.ActOnDefs(getCurScope(), TagDecl, Tok.getLocation(),
2704                         Tok.getIdentifierInfo(), Fields);
2705       FieldDecls.insert(FieldDecls.end(), Fields.begin(), Fields.end());
2706       ConsumeToken();
2707       ExpectAndConsume(tok::r_paren, diag::err_expected_rparen);
2708     }
2709
2710     if (Tok.is(tok::semi)) {
2711       ConsumeToken();
2712     } else if (Tok.is(tok::r_brace)) {
2713       ExpectAndConsume(tok::semi, diag::ext_expected_semi_decl_list);
2714       break;
2715     } else {
2716       ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list);
2717       // Skip to end of block or statement to avoid ext-warning on extra ';'.
2718       SkipUntil(tok::r_brace, true, true);
2719       // If we stopped at a ';', eat it.
2720       if (Tok.is(tok::semi)) ConsumeToken();
2721     }
2722   }
2723
2724   T.consumeClose();
2725
2726   ParsedAttributes attrs(AttrFactory);
2727   // If attributes exist after struct contents, parse them.
2728   MaybeParseGNUAttributes(attrs);
2729
2730   Actions.ActOnFields(getCurScope(),
2731                       RecordLoc, TagDecl, FieldDecls,
2732                       T.getOpenLocation(), T.getCloseLocation(),
2733                       attrs.getList());
2734   StructScope.Exit();
2735   Actions.ActOnTagFinishDefinition(getCurScope(), TagDecl,
2736                                    T.getCloseLocation());
2737 }
2738
2739 /// ParseEnumSpecifier
2740 ///       enum-specifier: [C99 6.7.2.2]
2741 ///         'enum' identifier[opt] '{' enumerator-list '}'
2742 ///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}'
2743 /// [GNU]   'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt]
2744 ///                                                 '}' attributes[opt]
2745 ///         'enum' identifier
2746 /// [GNU]   'enum' attributes[opt] identifier
2747 ///
2748 /// [C++0x] enum-head '{' enumerator-list[opt] '}'
2749 /// [C++0x] enum-head '{' enumerator-list ','  '}'
2750 ///
2751 ///       enum-head: [C++0x]
2752 ///         enum-key attributes[opt] identifier[opt] enum-base[opt]
2753 ///         enum-key attributes[opt] nested-name-specifier identifier enum-base[opt]
2754 ///
2755 ///       enum-key: [C++0x]
2756 ///         'enum'
2757 ///         'enum' 'class'
2758 ///         'enum' 'struct'
2759 ///
2760 ///       enum-base: [C++0x]
2761 ///         ':' type-specifier-seq
2762 ///
2763 /// [C++] elaborated-type-specifier:
2764 /// [C++]   'enum' '::'[opt] nested-name-specifier[opt] identifier
2765 ///
2766 void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
2767                                 const ParsedTemplateInfo &TemplateInfo,
2768                                 AccessSpecifier AS) {
2769   // Parse the tag portion of this.
2770   if (Tok.is(tok::code_completion)) {
2771     // Code completion for an enum name.
2772     Actions.CodeCompleteTag(getCurScope(), DeclSpec::TST_enum);
2773     return cutOffParsing();
2774   }
2775
2776   bool IsScopedEnum = false;
2777   bool IsScopedUsingClassTag = false;
2778
2779   if (getLang().CPlusPlus0x &&
2780       (Tok.is(tok::kw_class) || Tok.is(tok::kw_struct))) {
2781     IsScopedEnum = true;
2782     IsScopedUsingClassTag = Tok.is(tok::kw_class);
2783     ConsumeToken();
2784   }
2785
2786   // If attributes exist after tag, parse them.
2787   ParsedAttributes attrs(AttrFactory);
2788   MaybeParseGNUAttributes(attrs);
2789
2790   bool AllowFixedUnderlyingType
2791     = getLang().CPlusPlus0x || getLang().MicrosoftExt || getLang().ObjC2;
2792
2793   CXXScopeSpec &SS = DS.getTypeSpecScope();
2794   if (getLang().CPlusPlus) {
2795     // "enum foo : bar;" is not a potential typo for "enum foo::bar;"
2796     // if a fixed underlying type is allowed.
2797     ColonProtectionRAIIObject X(*this, AllowFixedUnderlyingType);
2798
2799     if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false))
2800       return;
2801
2802     if (SS.isSet() && Tok.isNot(tok::identifier)) {
2803       Diag(Tok, diag::err_expected_ident);
2804       if (Tok.isNot(tok::l_brace)) {
2805         // Has no name and is not a definition.
2806         // Skip the rest of this declarator, up until the comma or semicolon.
2807         SkipUntil(tok::comma, true);
2808         return;
2809       }
2810     }
2811   }
2812
2813   // Must have either 'enum name' or 'enum {...}'.
2814   if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace) &&
2815       (AllowFixedUnderlyingType && Tok.isNot(tok::colon))) {
2816     Diag(Tok, diag::err_expected_ident_lbrace);
2817
2818     // Skip the rest of this declarator, up until the comma or semicolon.
2819     SkipUntil(tok::comma, true);
2820     return;
2821   }
2822
2823   // If an identifier is present, consume and remember it.
2824   IdentifierInfo *Name = 0;
2825   SourceLocation NameLoc;
2826   if (Tok.is(tok::identifier)) {
2827     Name = Tok.getIdentifierInfo();
2828     NameLoc = ConsumeToken();
2829   }
2830
2831   if (!Name && IsScopedEnum) {
2832     // C++0x 7.2p2: The optional identifier shall not be omitted in the
2833     // declaration of a scoped enumeration.
2834     Diag(Tok, diag::err_scoped_enum_missing_identifier);
2835     IsScopedEnum = false;
2836     IsScopedUsingClassTag = false;
2837   }
2838
2839   TypeResult BaseType;
2840
2841   // Parse the fixed underlying type.
2842   if (AllowFixedUnderlyingType && Tok.is(tok::colon)) {
2843     bool PossibleBitfield = false;
2844     if (getCurScope()->getFlags() & Scope::ClassScope) {
2845       // If we're in class scope, this can either be an enum declaration with
2846       // an underlying type, or a declaration of a bitfield member. We try to
2847       // use a simple disambiguation scheme first to catch the common cases
2848       // (integer literal, sizeof); if it's still ambiguous, we then consider
2849       // anything that's a simple-type-specifier followed by '(' as an
2850       // expression. This suffices because function types are not valid
2851       // underlying types anyway.
2852       TPResult TPR = isExpressionOrTypeSpecifierSimple(NextToken().getKind());
2853       // If the next token starts an expression, we know we're parsing a
2854       // bit-field. This is the common case.
2855       if (TPR == TPResult::True())
2856         PossibleBitfield = true;
2857       // If the next token starts a type-specifier-seq, it may be either a
2858       // a fixed underlying type or the start of a function-style cast in C++;
2859       // lookahead one more token to see if it's obvious that we have a
2860       // fixed underlying type.
2861       else if (TPR == TPResult::False() &&
2862                GetLookAheadToken(2).getKind() == tok::semi) {
2863         // Consume the ':'.
2864         ConsumeToken();
2865       } else {
2866         // We have the start of a type-specifier-seq, so we have to perform
2867         // tentative parsing to determine whether we have an expression or a
2868         // type.
2869         TentativeParsingAction TPA(*this);
2870
2871         // Consume the ':'.
2872         ConsumeToken();
2873
2874         if ((getLang().CPlusPlus &&
2875              isCXXDeclarationSpecifier() != TPResult::True()) ||
2876             (!getLang().CPlusPlus && !isDeclarationSpecifier(true))) {
2877           // We'll parse this as a bitfield later.
2878           PossibleBitfield = true;
2879           TPA.Revert();
2880         } else {
2881           // We have a type-specifier-seq.
2882           TPA.Commit();
2883         }
2884       }
2885     } else {
2886       // Consume the ':'.
2887       ConsumeToken();
2888     }
2889
2890     if (!PossibleBitfield) {
2891       SourceRange Range;
2892       BaseType = ParseTypeName(&Range);
2893
2894       if (!getLang().CPlusPlus0x && !getLang().ObjC2)
2895         Diag(StartLoc, diag::ext_ms_enum_fixed_underlying_type)
2896           << Range;
2897     }
2898   }
2899
2900   // There are three options here.  If we have 'enum foo;', then this is a
2901   // forward declaration.  If we have 'enum foo {...' then this is a
2902   // definition. Otherwise we have something like 'enum foo xyz', a reference.
2903   //
2904   // This is needed to handle stuff like this right (C99 6.7.2.3p11):
2905   // enum foo {..};  void bar() { enum foo; }    <- new foo in bar.
2906   // enum foo {..};  void bar() { enum foo x; }  <- use of old foo.
2907   //
2908   Sema::TagUseKind TUK;
2909   if (Tok.is(tok::l_brace))
2910     TUK = Sema::TUK_Definition;
2911   else if (Tok.is(tok::semi))
2912     TUK = Sema::TUK_Declaration;
2913   else
2914     TUK = Sema::TUK_Reference;
2915
2916   // enums cannot be templates, although they can be referenced from a
2917   // template.
2918   if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
2919       TUK != Sema::TUK_Reference) {
2920     Diag(Tok, diag::err_enum_template);
2921
2922     // Skip the rest of this declarator, up until the comma or semicolon.
2923     SkipUntil(tok::comma, true);
2924     return;
2925   }
2926
2927   if (!Name && TUK != Sema::TUK_Definition) {
2928     Diag(Tok, diag::err_enumerator_unnamed_no_def);
2929
2930     // Skip the rest of this declarator, up until the comma or semicolon.
2931     SkipUntil(tok::comma, true);
2932     return;
2933   }
2934
2935   bool Owned = false;
2936   bool IsDependent = false;
2937   const char *PrevSpec = 0;
2938   unsigned DiagID;
2939   Decl *TagDecl = Actions.ActOnTag(getCurScope(), DeclSpec::TST_enum, TUK,
2940                                    StartLoc, SS, Name, NameLoc, attrs.getList(),
2941                                    AS, DS.getModulePrivateSpecLoc(),
2942                                    MultiTemplateParamsArg(Actions),
2943                                    Owned, IsDependent, IsScopedEnum,
2944                                    IsScopedUsingClassTag, BaseType);
2945
2946   if (IsDependent) {
2947     // This enum has a dependent nested-name-specifier. Handle it as a
2948     // dependent tag.
2949     if (!Name) {
2950       DS.SetTypeSpecError();
2951       Diag(Tok, diag::err_expected_type_name_after_typename);
2952       return;
2953     }
2954
2955     TypeResult Type = Actions.ActOnDependentTag(getCurScope(), DeclSpec::TST_enum,
2956                                                 TUK, SS, Name, StartLoc,
2957                                                 NameLoc);
2958     if (Type.isInvalid()) {
2959       DS.SetTypeSpecError();
2960       return;
2961     }
2962
2963     if (DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc,
2964                            NameLoc.isValid() ? NameLoc : StartLoc,
2965                            PrevSpec, DiagID, Type.get()))
2966       Diag(StartLoc, DiagID) << PrevSpec;
2967
2968     return;
2969   }
2970
2971   if (!TagDecl) {
2972     // The action failed to produce an enumeration tag. If this is a
2973     // definition, consume the entire definition.
2974     if (Tok.is(tok::l_brace)) {
2975       ConsumeBrace();
2976       SkipUntil(tok::r_brace);
2977     }
2978
2979     DS.SetTypeSpecError();
2980     return;
2981   }
2982
2983   if (Tok.is(tok::l_brace))
2984     ParseEnumBody(StartLoc, TagDecl);
2985
2986   if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc,
2987                          NameLoc.isValid() ? NameLoc : StartLoc,
2988                          PrevSpec, DiagID, TagDecl, Owned))
2989     Diag(StartLoc, DiagID) << PrevSpec;
2990 }
2991
2992 /// ParseEnumBody - Parse a {} enclosed enumerator-list.
2993 ///       enumerator-list:
2994 ///         enumerator
2995 ///         enumerator-list ',' enumerator
2996 ///       enumerator:
2997 ///         enumeration-constant
2998 ///         enumeration-constant '=' constant-expression
2999 ///       enumeration-constant:
3000 ///         identifier
3001 ///
3002 void Parser::ParseEnumBody(SourceLocation StartLoc, Decl *EnumDecl) {
3003   // Enter the scope of the enum body and start the definition.
3004   ParseScope EnumScope(this, Scope::DeclScope);
3005   Actions.ActOnTagStartDefinition(getCurScope(), EnumDecl);
3006
3007   BalancedDelimiterTracker T(*this, tok::l_brace);
3008   T.consumeOpen();
3009
3010   // C does not allow an empty enumerator-list, C++ does [dcl.enum].
3011   if (Tok.is(tok::r_brace) && !getLang().CPlusPlus)
3012     Diag(Tok, diag::error_empty_enum);
3013
3014   SmallVector<Decl *, 32> EnumConstantDecls;
3015
3016   Decl *LastEnumConstDecl = 0;
3017
3018   // Parse the enumerator-list.
3019   while (Tok.is(tok::identifier)) {
3020     IdentifierInfo *Ident = Tok.getIdentifierInfo();
3021     SourceLocation IdentLoc = ConsumeToken();
3022
3023     // If attributes exist after the enumerator, parse them.
3024     ParsedAttributes attrs(AttrFactory);
3025     MaybeParseGNUAttributes(attrs);
3026
3027     SourceLocation EqualLoc;
3028     ExprResult AssignedVal;
3029     if (Tok.is(tok::equal)) {
3030       EqualLoc = ConsumeToken();
3031       AssignedVal = ParseConstantExpression();
3032       if (AssignedVal.isInvalid())
3033         SkipUntil(tok::comma, tok::r_brace, true, true);
3034     }
3035
3036     // Install the enumerator constant into EnumDecl.
3037     Decl *EnumConstDecl = Actions.ActOnEnumConstant(getCurScope(), EnumDecl,
3038                                                     LastEnumConstDecl,
3039                                                     IdentLoc, Ident,
3040                                                     attrs.getList(), EqualLoc,
3041                                                     AssignedVal.release());
3042     EnumConstantDecls.push_back(EnumConstDecl);
3043     LastEnumConstDecl = EnumConstDecl;
3044
3045     if (Tok.is(tok::identifier)) {
3046       // We're missing a comma between enumerators.
3047       SourceLocation Loc = PP.getLocForEndOfToken(PrevTokLocation);
3048       Diag(Loc, diag::err_enumerator_list_missing_comma)
3049         << FixItHint::CreateInsertion(Loc, ", ");
3050       continue;
3051     }
3052
3053     if (Tok.isNot(tok::comma))
3054       break;
3055     SourceLocation CommaLoc = ConsumeToken();
3056
3057     if (Tok.isNot(tok::identifier) &&
3058         !(getLang().C99 || getLang().CPlusPlus0x))
3059       Diag(CommaLoc, diag::ext_enumerator_list_comma)
3060         << getLang().CPlusPlus
3061         << FixItHint::CreateRemoval(CommaLoc);
3062   }
3063
3064   // Eat the }.
3065   T.consumeClose();
3066
3067   // If attributes exist after the identifier list, parse them.
3068   ParsedAttributes attrs(AttrFactory);
3069   MaybeParseGNUAttributes(attrs);
3070
3071   Actions.ActOnEnumBody(StartLoc, T.getOpenLocation(), T.getCloseLocation(),
3072                         EnumDecl, EnumConstantDecls.data(),
3073                         EnumConstantDecls.size(), getCurScope(),
3074                         attrs.getList());
3075
3076   EnumScope.Exit();
3077   Actions.ActOnTagFinishDefinition(getCurScope(), EnumDecl,
3078                                    T.getCloseLocation());
3079 }
3080
3081 /// isTypeSpecifierQualifier - Return true if the current token could be the
3082 /// start of a type-qualifier-list.
3083 bool Parser::isTypeQualifier() const {
3084   switch (Tok.getKind()) {
3085   default: return false;
3086
3087     // type-qualifier only in OpenCL
3088   case tok::kw_private:
3089     return getLang().OpenCL;
3090
3091     // type-qualifier
3092   case tok::kw_const:
3093   case tok::kw_volatile:
3094   case tok::kw_restrict:
3095   case tok::kw___private:
3096   case tok::kw___local:
3097   case tok::kw___global:
3098   case tok::kw___constant:
3099   case tok::kw___read_only:
3100   case tok::kw___read_write:
3101   case tok::kw___write_only:
3102     return true;
3103   }
3104 }
3105
3106 /// isKnownToBeTypeSpecifier - Return true if we know that the specified token
3107 /// is definitely a type-specifier.  Return false if it isn't part of a type
3108 /// specifier or if we're not sure.
3109 bool Parser::isKnownToBeTypeSpecifier(const Token &Tok) const {
3110   switch (Tok.getKind()) {
3111   default: return false;
3112     // type-specifiers
3113   case tok::kw_short:
3114   case tok::kw_long:
3115   case tok::kw___int64:
3116   case tok::kw_signed:
3117   case tok::kw_unsigned:
3118   case tok::kw__Complex:
3119   case tok::kw__Imaginary:
3120   case tok::kw_void:
3121   case tok::kw_char:
3122   case tok::kw_wchar_t:
3123   case tok::kw_char16_t:
3124   case tok::kw_char32_t:
3125   case tok::kw_int:
3126   case tok::kw_half:
3127   case tok::kw_float:
3128   case tok::kw_double:
3129   case tok::kw_bool:
3130   case tok::kw__Bool:
3131   case tok::kw__Decimal32:
3132   case tok::kw__Decimal64:
3133   case tok::kw__Decimal128:
3134   case tok::kw___vector:
3135
3136     // struct-or-union-specifier (C99) or class-specifier (C++)
3137   case tok::kw_class:
3138   case tok::kw_struct:
3139   case tok::kw_union:
3140     // enum-specifier
3141   case tok::kw_enum:
3142
3143     // typedef-name
3144   case tok::annot_typename:
3145     return true;
3146   }
3147 }
3148
3149 /// isTypeSpecifierQualifier - Return true if the current token could be the
3150 /// start of a specifier-qualifier-list.
3151 bool Parser::isTypeSpecifierQualifier() {
3152   switch (Tok.getKind()) {
3153   default: return false;
3154
3155   case tok::identifier:   // foo::bar
3156     if (TryAltiVecVectorToken())
3157       return true;
3158     // Fall through.
3159   case tok::kw_typename:  // typename T::type
3160     // Annotate typenames and C++ scope specifiers.  If we get one, just
3161     // recurse to handle whatever we get.
3162     if (TryAnnotateTypeOrScopeToken())
3163       return true;
3164     if (Tok.is(tok::identifier))
3165       return false;
3166     return isTypeSpecifierQualifier();
3167
3168   case tok::coloncolon:   // ::foo::bar
3169     if (NextToken().is(tok::kw_new) ||    // ::new
3170         NextToken().is(tok::kw_delete))   // ::delete
3171       return false;
3172
3173     if (TryAnnotateTypeOrScopeToken())
3174       return true;
3175     return isTypeSpecifierQualifier();
3176
3177     // GNU attributes support.
3178   case tok::kw___attribute:
3179     // GNU typeof support.
3180   case tok::kw_typeof:
3181
3182     // type-specifiers
3183   case tok::kw_short:
3184   case tok::kw_long:
3185   case tok::kw___int64:
3186   case tok::kw_signed:
3187   case tok::kw_unsigned:
3188   case tok::kw__Complex:
3189   case tok::kw__Imaginary:
3190   case tok::kw_void:
3191   case tok::kw_char:
3192   case tok::kw_wchar_t:
3193   case tok::kw_char16_t:
3194   case tok::kw_char32_t:
3195   case tok::kw_int:
3196   case tok::kw_half:
3197   case tok::kw_float:
3198   case tok::kw_double:
3199   case tok::kw_bool:
3200   case tok::kw__Bool:
3201   case tok::kw__Decimal32:
3202   case tok::kw__Decimal64:
3203   case tok::kw__Decimal128:
3204   case tok::kw___vector:
3205
3206     // struct-or-union-specifier (C99) or class-specifier (C++)
3207   case tok::kw_class:
3208   case tok::kw_struct:
3209   case tok::kw_union:
3210     // enum-specifier
3211   case tok::kw_enum:
3212
3213     // type-qualifier
3214   case tok::kw_const:
3215   case tok::kw_volatile:
3216   case tok::kw_restrict:
3217
3218     // typedef-name
3219   case tok::annot_typename:
3220     return true;
3221
3222     // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
3223   case tok::less:
3224     return getLang().ObjC1;
3225
3226   case tok::kw___cdecl:
3227   case tok::kw___stdcall:
3228   case tok::kw___fastcall:
3229   case tok::kw___thiscall:
3230   case tok::kw___w64:
3231   case tok::kw___ptr64:
3232   case tok::kw___ptr32:
3233   case tok::kw___pascal:
3234   case tok::kw___unaligned:
3235
3236   case tok::kw___private:
3237   case tok::kw___local:
3238   case tok::kw___global:
3239   case tok::kw___constant:
3240   case tok::kw___read_only:
3241   case tok::kw___read_write:
3242   case tok::kw___write_only:
3243
3244     return true;
3245
3246   case tok::kw_private:
3247     return getLang().OpenCL;
3248
3249   // C1x _Atomic()
3250   case tok::kw__Atomic:
3251     return true;
3252   }
3253 }
3254
3255 /// isDeclarationSpecifier() - Return true if the current token is part of a
3256 /// declaration specifier.
3257 ///
3258 /// \param DisambiguatingWithExpression True to indicate that the purpose of
3259 /// this check is to disambiguate between an expression and a declaration.
3260 bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) {
3261   switch (Tok.getKind()) {
3262   default: return false;
3263
3264   case tok::kw_private:
3265     return getLang().OpenCL;
3266
3267   case tok::identifier:   // foo::bar
3268     // Unfortunate hack to support "Class.factoryMethod" notation.
3269     if (getLang().ObjC1 && NextToken().is(tok::period))
3270       return false;
3271     if (TryAltiVecVectorToken())
3272       return true;
3273     // Fall through.
3274   case tok::kw_typename: // typename T::type
3275     // Annotate typenames and C++ scope specifiers.  If we get one, just
3276     // recurse to handle whatever we get.
3277     if (TryAnnotateTypeOrScopeToken())
3278       return true;
3279     if (Tok.is(tok::identifier))
3280       return false;
3281
3282     // If we're in Objective-C and we have an Objective-C class type followed
3283     // by an identifier and then either ':' or ']', in a place where an
3284     // expression is permitted, then this is probably a class message send
3285     // missing the initial '['. In this case, we won't consider this to be
3286     // the start of a declaration.
3287     if (DisambiguatingWithExpression &&
3288         isStartOfObjCClassMessageMissingOpenBracket())
3289       return false;
3290
3291     return isDeclarationSpecifier();
3292
3293   case tok::coloncolon:   // ::foo::bar
3294     if (NextToken().is(tok::kw_new) ||    // ::new
3295         NextToken().is(tok::kw_delete))   // ::delete
3296       return false;
3297
3298     // Annotate typenames and C++ scope specifiers.  If we get one, just
3299     // recurse to handle whatever we get.
3300     if (TryAnnotateTypeOrScopeToken())
3301       return true;
3302     return isDeclarationSpecifier();
3303
3304     // storage-class-specifier
3305   case tok::kw_typedef:
3306   case tok::kw_extern:
3307   case tok::kw___private_extern__:
3308   case tok::kw_static:
3309   case tok::kw_auto:
3310   case tok::kw_register:
3311   case tok::kw___thread:
3312
3313     // Modules
3314   case tok::kw___module_private__:
3315
3316     // type-specifiers
3317   case tok::kw_short:
3318   case tok::kw_long:
3319   case tok::kw___int64:
3320   case tok::kw_signed:
3321   case tok::kw_unsigned:
3322   case tok::kw__Complex:
3323   case tok::kw__Imaginary:
3324   case tok::kw_void:
3325   case tok::kw_char:
3326   case tok::kw_wchar_t:
3327   case tok::kw_char16_t:
3328   case tok::kw_char32_t:
3329
3330   case tok::kw_int:
3331   case tok::kw_half:
3332   case tok::kw_float:
3333   case tok::kw_double:
3334   case tok::kw_bool:
3335   case tok::kw__Bool:
3336   case tok::kw__Decimal32:
3337   case tok::kw__Decimal64:
3338   case tok::kw__Decimal128:
3339   case tok::kw___vector:
3340
3341     // struct-or-union-specifier (C99) or class-specifier (C++)
3342   case tok::kw_class:
3343   case tok::kw_struct:
3344   case tok::kw_union:
3345     // enum-specifier
3346   case tok::kw_enum:
3347
3348     // type-qualifier
3349   case tok::kw_const:
3350   case tok::kw_volatile:
3351   case tok::kw_restrict:
3352
3353     // function-specifier
3354   case tok::kw_inline:
3355   case tok::kw_virtual:
3356   case tok::kw_explicit:
3357
3358     // static_assert-declaration
3359   case tok::kw__Static_assert:
3360
3361     // GNU typeof support.
3362   case tok::kw_typeof:
3363
3364     // GNU attributes.
3365   case tok::kw___attribute:
3366     return true;
3367
3368     // C++0x decltype.
3369   case tok::kw_decltype:
3370     return true;
3371
3372     // C1x _Atomic()
3373   case tok::kw__Atomic:
3374     return true;
3375
3376     // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
3377   case tok::less:
3378     return getLang().ObjC1;
3379
3380     // typedef-name
3381   case tok::annot_typename:
3382     return !DisambiguatingWithExpression ||
3383            !isStartOfObjCClassMessageMissingOpenBracket();
3384
3385   case tok::kw___declspec:
3386   case tok::kw___cdecl:
3387   case tok::kw___stdcall:
3388   case tok::kw___fastcall:
3389   case tok::kw___thiscall:
3390   case tok::kw___w64:
3391   case tok::kw___ptr64:
3392   case tok::kw___ptr32:
3393   case tok::kw___forceinline:
3394   case tok::kw___pascal:
3395   case tok::kw___unaligned:
3396
3397   case tok::kw___private:
3398   case tok::kw___local:
3399   case tok::kw___global:
3400   case tok::kw___constant:
3401   case tok::kw___read_only:
3402   case tok::kw___read_write:
3403   case tok::kw___write_only:
3404
3405     return true;
3406   }
3407 }
3408
3409 bool Parser::isConstructorDeclarator() {
3410   TentativeParsingAction TPA(*this);
3411
3412   // Parse the C++ scope specifier.
3413   CXXScopeSpec SS;
3414   if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), true)) {
3415     TPA.Revert();
3416     return false;
3417   }
3418
3419   // Parse the constructor name.
3420   if (Tok.is(tok::identifier) || Tok.is(tok::annot_template_id)) {
3421     // We already know that we have a constructor name; just consume
3422     // the token.
3423     ConsumeToken();
3424   } else {
3425     TPA.Revert();
3426     return false;
3427   }
3428
3429   // Current class name must be followed by a left parentheses.
3430   if (Tok.isNot(tok::l_paren)) {
3431     TPA.Revert();
3432     return false;
3433   }
3434   ConsumeParen();
3435
3436   // A right parentheses or ellipsis signals that we have a constructor.
3437   if (Tok.is(tok::r_paren) || Tok.is(tok::ellipsis)) {
3438     TPA.Revert();
3439     return true;
3440   }
3441
3442   // If we need to, enter the specified scope.
3443   DeclaratorScopeObj DeclScopeObj(*this, SS);
3444   if (SS.isSet() && Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
3445     DeclScopeObj.EnterDeclaratorScope();
3446
3447   // Optionally skip Microsoft attributes.
3448   ParsedAttributes Attrs(AttrFactory);
3449   MaybeParseMicrosoftAttributes(Attrs);
3450
3451   // Check whether the next token(s) are part of a declaration
3452   // specifier, in which case we have the start of a parameter and,
3453   // therefore, we know that this is a constructor.
3454   bool IsConstructor = isDeclarationSpecifier();
3455   TPA.Revert();
3456   return IsConstructor;
3457 }
3458
3459 /// ParseTypeQualifierListOpt
3460 ///          type-qualifier-list: [C99 6.7.5]
3461 ///            type-qualifier
3462 /// [vendor]   attributes
3463 ///              [ only if VendorAttributesAllowed=true ]
3464 ///            type-qualifier-list type-qualifier
3465 /// [vendor]   type-qualifier-list attributes
3466 ///              [ only if VendorAttributesAllowed=true ]
3467 /// [C++0x]    attribute-specifier[opt] is allowed before cv-qualifier-seq
3468 ///              [ only if CXX0XAttributesAllowed=true ]
3469 /// Note: vendor can be GNU, MS, etc.
3470 ///
3471 void Parser::ParseTypeQualifierListOpt(DeclSpec &DS,
3472                                        bool VendorAttributesAllowed,
3473                                        bool CXX0XAttributesAllowed) {
3474   if (getLang().CPlusPlus0x && isCXX0XAttributeSpecifier()) {
3475     SourceLocation Loc = Tok.getLocation();
3476     ParsedAttributesWithRange attrs(AttrFactory);
3477     ParseCXX0XAttributes(attrs);
3478     if (CXX0XAttributesAllowed)
3479       DS.takeAttributesFrom(attrs);
3480     else
3481       Diag(Loc, diag::err_attributes_not_allowed);
3482   }
3483
3484   SourceLocation EndLoc;
3485
3486   while (1) {
3487     bool isInvalid = false;
3488     const char *PrevSpec = 0;
3489     unsigned DiagID = 0;
3490     SourceLocation Loc = Tok.getLocation();
3491
3492     switch (Tok.getKind()) {
3493     case tok::code_completion:
3494       Actions.CodeCompleteTypeQualifiers(DS);
3495       return cutOffParsing();
3496
3497     case tok::kw_const:
3498       isInvalid = DS.SetTypeQual(DeclSpec::TQ_const   , Loc, PrevSpec, DiagID,
3499                                  getLang());
3500       break;
3501     case tok::kw_volatile:
3502       isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
3503                                  getLang());
3504       break;
3505     case tok::kw_restrict:
3506       isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
3507                                  getLang());
3508       break;
3509
3510     // OpenCL qualifiers:
3511     case tok::kw_private:
3512       if (!getLang().OpenCL)
3513         goto DoneWithTypeQuals;
3514     case tok::kw___private:
3515     case tok::kw___global:
3516     case tok::kw___local:
3517     case tok::kw___constant:
3518     case tok::kw___read_only:
3519     case tok::kw___write_only:
3520     case tok::kw___read_write:
3521       ParseOpenCLQualifiers(DS);
3522       break;
3523
3524     case tok::kw___w64:
3525     case tok::kw___ptr64:
3526     case tok::kw___ptr32:
3527     case tok::kw___cdecl:
3528     case tok::kw___stdcall:
3529     case tok::kw___fastcall:
3530     case tok::kw___thiscall:
3531     case tok::kw___unaligned:
3532       if (VendorAttributesAllowed) {
3533         ParseMicrosoftTypeAttributes(DS.getAttributes());
3534         continue;
3535       }
3536       goto DoneWithTypeQuals;
3537     case tok::kw___pascal:
3538       if (VendorAttributesAllowed) {
3539         ParseBorlandTypeAttributes(DS.getAttributes());
3540         continue;
3541       }
3542       goto DoneWithTypeQuals;
3543     case tok::kw___attribute:
3544       if (VendorAttributesAllowed) {
3545         ParseGNUAttributes(DS.getAttributes());
3546         continue; // do *not* consume the next token!
3547       }
3548       // otherwise, FALL THROUGH!
3549     default:
3550       DoneWithTypeQuals:
3551       // If this is not a type-qualifier token, we're done reading type
3552       // qualifiers.  First verify that DeclSpec's are consistent.
3553       DS.Finish(Diags, PP);
3554       if (EndLoc.isValid())
3555         DS.SetRangeEnd(EndLoc);
3556       return;
3557     }
3558
3559     // If the specifier combination wasn't legal, issue a diagnostic.
3560     if (isInvalid) {
3561       assert(PrevSpec && "Method did not return previous specifier!");
3562       Diag(Tok, DiagID) << PrevSpec;
3563     }
3564     EndLoc = ConsumeToken();
3565   }
3566 }
3567
3568
3569 /// ParseDeclarator - Parse and verify a newly-initialized declarator.
3570 ///
3571 void Parser::ParseDeclarator(Declarator &D) {
3572   /// This implements the 'declarator' production in the C grammar, then checks
3573   /// for well-formedness and issues diagnostics.
3574   ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
3575 }
3576
3577 /// ParseDeclaratorInternal - Parse a C or C++ declarator. The direct-declarator
3578 /// is parsed by the function passed to it. Pass null, and the direct-declarator
3579 /// isn't parsed at all, making this function effectively parse the C++
3580 /// ptr-operator production.
3581 ///
3582 ///       declarator: [C99 6.7.5] [C++ 8p4, dcl.decl]
3583 /// [C]     pointer[opt] direct-declarator
3584 /// [C++]   direct-declarator
3585 /// [C++]   ptr-operator declarator
3586 ///
3587 ///       pointer: [C99 6.7.5]
3588 ///         '*' type-qualifier-list[opt]
3589 ///         '*' type-qualifier-list[opt] pointer
3590 ///
3591 ///       ptr-operator:
3592 ///         '*' cv-qualifier-seq[opt]
3593 ///         '&'
3594 /// [C++0x] '&&'
3595 /// [GNU]   '&' restrict[opt] attributes[opt]
3596 /// [GNU?]  '&&' restrict[opt] attributes[opt]
3597 ///         '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
3598 void Parser::ParseDeclaratorInternal(Declarator &D,
3599                                      DirectDeclParseFunction DirectDeclParser) {
3600   if (Diags.hasAllExtensionsSilenced())
3601     D.setExtension();
3602
3603   // C++ member pointers start with a '::' or a nested-name.
3604   // Member pointers get special handling, since there's no place for the
3605   // scope spec in the generic path below.
3606   if (getLang().CPlusPlus &&
3607       (Tok.is(tok::coloncolon) || Tok.is(tok::identifier) ||
3608        Tok.is(tok::annot_cxxscope))) {
3609     CXXScopeSpec SS;
3610     ParseOptionalCXXScopeSpecifier(SS, ParsedType(), true); // ignore fail
3611
3612     if (SS.isNotEmpty()) {
3613       if (Tok.isNot(tok::star)) {
3614         // The scope spec really belongs to the direct-declarator.
3615         D.getCXXScopeSpec() = SS;
3616         if (DirectDeclParser)
3617           (this->*DirectDeclParser)(D);
3618         return;
3619       }
3620
3621       SourceLocation Loc = ConsumeToken();
3622       D.SetRangeEnd(Loc);
3623       DeclSpec DS(AttrFactory);
3624       ParseTypeQualifierListOpt(DS);
3625       D.ExtendWithDeclSpec(DS);
3626
3627       // Recurse to parse whatever is left.
3628       ParseDeclaratorInternal(D, DirectDeclParser);
3629
3630       // Sema will have to catch (syntactically invalid) pointers into global
3631       // scope. It has to catch pointers into namespace scope anyway.
3632       D.AddTypeInfo(DeclaratorChunk::getMemberPointer(SS,DS.getTypeQualifiers(),
3633                                                       Loc),
3634                     DS.getAttributes(),
3635                     /* Don't replace range end. */SourceLocation());
3636       return;
3637     }
3638   }
3639
3640   tok::TokenKind Kind = Tok.getKind();
3641   // Not a pointer, C++ reference, or block.
3642   if (Kind != tok::star && Kind != tok::caret &&
3643       (Kind != tok::amp || !getLang().CPlusPlus) &&
3644       // We parse rvalue refs in C++03, because otherwise the errors are scary.
3645       (Kind != tok::ampamp || !getLang().CPlusPlus)) {
3646     if (DirectDeclParser)
3647       (this->*DirectDeclParser)(D);
3648     return;
3649   }
3650
3651   // Otherwise, '*' -> pointer, '^' -> block, '&' -> lvalue reference,
3652   // '&&' -> rvalue reference
3653   SourceLocation Loc = ConsumeToken();  // Eat the *, ^, & or &&.
3654   D.SetRangeEnd(Loc);
3655
3656   if (Kind == tok::star || Kind == tok::caret) {
3657     // Is a pointer.
3658     DeclSpec DS(AttrFactory);
3659
3660     ParseTypeQualifierListOpt(DS);
3661     D.ExtendWithDeclSpec(DS);
3662
3663     // Recursively parse the declarator.
3664     ParseDeclaratorInternal(D, DirectDeclParser);
3665     if (Kind == tok::star)
3666       // Remember that we parsed a pointer type, and remember the type-quals.
3667       D.AddTypeInfo(DeclaratorChunk::getPointer(DS.getTypeQualifiers(), Loc,
3668                                                 DS.getConstSpecLoc(),
3669                                                 DS.getVolatileSpecLoc(),
3670                                                 DS.getRestrictSpecLoc()),
3671                     DS.getAttributes(),
3672                     SourceLocation());
3673     else
3674       // Remember that we parsed a Block type, and remember the type-quals.
3675       D.AddTypeInfo(DeclaratorChunk::getBlockPointer(DS.getTypeQualifiers(),
3676                                                      Loc),
3677                     DS.getAttributes(),
3678                     SourceLocation());
3679   } else {
3680     // Is a reference
3681     DeclSpec DS(AttrFactory);
3682
3683     // Complain about rvalue references in C++03, but then go on and build
3684     // the declarator.
3685     if (Kind == tok::ampamp && !getLang().CPlusPlus0x)
3686       Diag(Loc, diag::ext_rvalue_reference);
3687
3688     // C++ 8.3.2p1: cv-qualified references are ill-formed except when the
3689     // cv-qualifiers are introduced through the use of a typedef or of a
3690     // template type argument, in which case the cv-qualifiers are ignored.
3691     //
3692     // [GNU] Retricted references are allowed.
3693     // [GNU] Attributes on references are allowed.
3694     // [C++0x] Attributes on references are not allowed.
3695     ParseTypeQualifierListOpt(DS, true, false);
3696     D.ExtendWithDeclSpec(DS);
3697
3698     if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) {
3699       if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
3700         Diag(DS.getConstSpecLoc(),
3701              diag::err_invalid_reference_qualifier_application) << "const";
3702       if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
3703         Diag(DS.getVolatileSpecLoc(),
3704              diag::err_invalid_reference_qualifier_application) << "volatile";
3705     }
3706
3707     // Recursively parse the declarator.
3708     ParseDeclaratorInternal(D, DirectDeclParser);
3709
3710     if (D.getNumTypeObjects() > 0) {
3711       // C++ [dcl.ref]p4: There shall be no references to references.
3712       DeclaratorChunk& InnerChunk = D.getTypeObject(D.getNumTypeObjects() - 1);
3713       if (InnerChunk.Kind == DeclaratorChunk::Reference) {
3714         if (const IdentifierInfo *II = D.getIdentifier())
3715           Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
3716            << II;
3717         else
3718           Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
3719             << "type name";
3720
3721         // Once we've complained about the reference-to-reference, we
3722         // can go ahead and build the (technically ill-formed)
3723         // declarator: reference collapsing will take care of it.
3724       }
3725     }
3726
3727     // Remember that we parsed a reference type. It doesn't have type-quals.
3728     D.AddTypeInfo(DeclaratorChunk::getReference(DS.getTypeQualifiers(), Loc,
3729                                                 Kind == tok::amp),
3730                   DS.getAttributes(),
3731                   SourceLocation());
3732   }
3733 }
3734
3735 /// ParseDirectDeclarator
3736 ///       direct-declarator: [C99 6.7.5]
3737 /// [C99]   identifier
3738 ///         '(' declarator ')'
3739 /// [GNU]   '(' attributes declarator ')'
3740 /// [C90]   direct-declarator '[' constant-expression[opt] ']'
3741 /// [C99]   direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
3742 /// [C99]   direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
3743 /// [C99]   direct-declarator '[' type-qual-list 'static' assignment-expr ']'
3744 /// [C99]   direct-declarator '[' type-qual-list[opt] '*' ']'
3745 ///         direct-declarator '(' parameter-type-list ')'
3746 ///         direct-declarator '(' identifier-list[opt] ')'
3747 /// [GNU]   direct-declarator '(' parameter-forward-declarations
3748 ///                    parameter-type-list[opt] ')'
3749 /// [C++]   direct-declarator '(' parameter-declaration-clause ')'
3750 ///                    cv-qualifier-seq[opt] exception-specification[opt]
3751 /// [C++]   declarator-id
3752 ///
3753 ///       declarator-id: [C++ 8]
3754 ///         '...'[opt] id-expression
3755 ///         '::'[opt] nested-name-specifier[opt] type-name
3756 ///
3757 ///       id-expression: [C++ 5.1]
3758 ///         unqualified-id
3759 ///         qualified-id
3760 ///
3761 ///       unqualified-id: [C++ 5.1]
3762 ///         identifier
3763 ///         operator-function-id
3764 ///         conversion-function-id
3765 ///          '~' class-name
3766 ///         template-id
3767 ///
3768 void Parser::ParseDirectDeclarator(Declarator &D) {
3769   DeclaratorScopeObj DeclScopeObj(*this, D.getCXXScopeSpec());
3770
3771   if (getLang().CPlusPlus && D.mayHaveIdentifier()) {
3772     // ParseDeclaratorInternal might already have parsed the scope.
3773     if (D.getCXXScopeSpec().isEmpty()) {
3774       ParseOptionalCXXScopeSpecifier(D.getCXXScopeSpec(), ParsedType(), true);
3775     }
3776
3777     if (D.getCXXScopeSpec().isValid()) {
3778       if (Actions.ShouldEnterDeclaratorScope(getCurScope(), D.getCXXScopeSpec()))
3779         // Change the declaration context for name lookup, until this function
3780         // is exited (and the declarator has been parsed).
3781         DeclScopeObj.EnterDeclaratorScope();
3782     }
3783
3784     // C++0x [dcl.fct]p14:
3785     //   There is a syntactic ambiguity when an ellipsis occurs at the end
3786     //   of a parameter-declaration-clause without a preceding comma. In
3787     //   this case, the ellipsis is parsed as part of the
3788     //   abstract-declarator if the type of the parameter names a template
3789     //   parameter pack that has not been expanded; otherwise, it is parsed
3790     //   as part of the parameter-declaration-clause.
3791     if (Tok.is(tok::ellipsis) &&
3792         !((D.getContext() == Declarator::PrototypeContext ||
3793            D.getContext() == Declarator::BlockLiteralContext) &&
3794           NextToken().is(tok::r_paren) &&
3795           !Actions.containsUnexpandedParameterPacks(D)))
3796       D.setEllipsisLoc(ConsumeToken());
3797
3798     if (Tok.is(tok::identifier) || Tok.is(tok::kw_operator) ||
3799         Tok.is(tok::annot_template_id) || Tok.is(tok::tilde)) {
3800       // We found something that indicates the start of an unqualified-id.
3801       // Parse that unqualified-id.
3802       bool AllowConstructorName;
3803       if (D.getDeclSpec().hasTypeSpecifier())
3804         AllowConstructorName = false;
3805       else if (D.getCXXScopeSpec().isSet())
3806         AllowConstructorName =
3807           (D.getContext() == Declarator::FileContext ||
3808            (D.getContext() == Declarator::MemberContext &&
3809             D.getDeclSpec().isFriendSpecified()));
3810       else
3811         AllowConstructorName = (D.getContext() == Declarator::MemberContext);
3812
3813       if (ParseUnqualifiedId(D.getCXXScopeSpec(),
3814                              /*EnteringContext=*/true,
3815                              /*AllowDestructorName=*/true,
3816                              AllowConstructorName,
3817                              ParsedType(),
3818                              D.getName()) ||
3819           // Once we're past the identifier, if the scope was bad, mark the
3820           // whole declarator bad.
3821           D.getCXXScopeSpec().isInvalid()) {
3822         D.SetIdentifier(0, Tok.getLocation());
3823         D.setInvalidType(true);
3824       } else {
3825         // Parsed the unqualified-id; update range information and move along.
3826         if (D.getSourceRange().getBegin().isInvalid())
3827           D.SetRangeBegin(D.getName().getSourceRange().getBegin());
3828         D.SetRangeEnd(D.getName().getSourceRange().getEnd());
3829       }
3830       goto PastIdentifier;
3831     }
3832   } else if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) {
3833     assert(!getLang().CPlusPlus &&
3834            "There's a C++-specific check for tok::identifier above");
3835     assert(Tok.getIdentifierInfo() && "Not an identifier?");
3836     D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
3837     ConsumeToken();
3838     goto PastIdentifier;
3839   }
3840
3841   if (Tok.is(tok::l_paren)) {
3842     // direct-declarator: '(' declarator ')'
3843     // direct-declarator: '(' attributes declarator ')'
3844     // Example: 'char (*X)'   or 'int (*XX)(void)'
3845     ParseParenDeclarator(D);
3846
3847     // If the declarator was parenthesized, we entered the declarator
3848     // scope when parsing the parenthesized declarator, then exited
3849     // the scope already. Re-enter the scope, if we need to.
3850     if (D.getCXXScopeSpec().isSet()) {
3851       // If there was an error parsing parenthesized declarator, declarator
3852       // scope may have been enterred before. Don't do it again.
3853       if (!D.isInvalidType() &&
3854           Actions.ShouldEnterDeclaratorScope(getCurScope(), D.getCXXScopeSpec()))
3855         // Change the declaration context for name lookup, until this function
3856         // is exited (and the declarator has been parsed).
3857         DeclScopeObj.EnterDeclaratorScope();
3858     }
3859   } else if (D.mayOmitIdentifier()) {
3860     // This could be something simple like "int" (in which case the declarator
3861     // portion is empty), if an abstract-declarator is allowed.
3862     D.SetIdentifier(0, Tok.getLocation());
3863   } else {
3864     if (D.getContext() == Declarator::MemberContext)
3865       Diag(Tok, diag::err_expected_member_name_or_semi)
3866         << D.getDeclSpec().getSourceRange();
3867     else if (getLang().CPlusPlus)
3868       Diag(Tok, diag::err_expected_unqualified_id) << getLang().CPlusPlus;
3869     else
3870       Diag(Tok, diag::err_expected_ident_lparen);
3871     D.SetIdentifier(0, Tok.getLocation());
3872     D.setInvalidType(true);
3873   }
3874
3875  PastIdentifier:
3876   assert(D.isPastIdentifier() &&
3877          "Haven't past the location of the identifier yet?");
3878
3879   // Don't parse attributes unless we have an identifier.
3880   if (D.getIdentifier())
3881     MaybeParseCXX0XAttributes(D);
3882
3883   while (1) {
3884     if (Tok.is(tok::l_paren)) {
3885       // The paren may be part of a C++ direct initializer, eg. "int x(1);".
3886       // In such a case, check if we actually have a function declarator; if it
3887       // is not, the declarator has been fully parsed.
3888       if (getLang().CPlusPlus && D.mayBeFollowedByCXXDirectInit()) {
3889         // When not in file scope, warn for ambiguous function declarators, just
3890         // in case the author intended it as a variable definition.
3891         bool warnIfAmbiguous = D.getContext() != Declarator::FileContext;
3892         if (!isCXXFunctionDeclarator(warnIfAmbiguous))
3893           break;
3894       }
3895       ParsedAttributes attrs(AttrFactory);
3896       BalancedDelimiterTracker T(*this, tok::l_paren);
3897       T.consumeOpen();
3898       ParseFunctionDeclarator(D, attrs, T);
3899     } else if (Tok.is(tok::l_square)) {
3900       ParseBracketDeclarator(D);
3901     } else {
3902       break;
3903     }
3904   }
3905 }
3906
3907 /// ParseParenDeclarator - We parsed the declarator D up to a paren.  This is
3908 /// only called before the identifier, so these are most likely just grouping
3909 /// parens for precedence.  If we find that these are actually function
3910 /// parameter parens in an abstract-declarator, we call ParseFunctionDeclarator.
3911 ///
3912 ///       direct-declarator:
3913 ///         '(' declarator ')'
3914 /// [GNU]   '(' attributes declarator ')'
3915 ///         direct-declarator '(' parameter-type-list ')'
3916 ///         direct-declarator '(' identifier-list[opt] ')'
3917 /// [GNU]   direct-declarator '(' parameter-forward-declarations
3918 ///                    parameter-type-list[opt] ')'
3919 ///
3920 void Parser::ParseParenDeclarator(Declarator &D) {
3921   BalancedDelimiterTracker T(*this, tok::l_paren);
3922   T.consumeOpen();
3923
3924   assert(!D.isPastIdentifier() && "Should be called before passing identifier");
3925
3926   // Eat any attributes before we look at whether this is a grouping or function
3927   // declarator paren.  If this is a grouping paren, the attribute applies to
3928   // the type being built up, for example:
3929   //     int (__attribute__(()) *x)(long y)
3930   // If this ends up not being a grouping paren, the attribute applies to the
3931   // first argument, for example:
3932   //     int (__attribute__(()) int x)
3933   // In either case, we need to eat any attributes to be able to determine what
3934   // sort of paren this is.
3935   //
3936   ParsedAttributes attrs(AttrFactory);
3937   bool RequiresArg = false;
3938   if (Tok.is(tok::kw___attribute)) {
3939     ParseGNUAttributes(attrs);
3940
3941     // We require that the argument list (if this is a non-grouping paren) be
3942     // present even if the attribute list was empty.
3943     RequiresArg = true;
3944   }
3945   // Eat any Microsoft extensions.
3946   if  (Tok.is(tok::kw___cdecl) || Tok.is(tok::kw___stdcall) ||
3947        Tok.is(tok::kw___thiscall) || Tok.is(tok::kw___fastcall) ||
3948        Tok.is(tok::kw___w64) || Tok.is(tok::kw___ptr64) ||
3949        Tok.is(tok::kw___ptr32) || Tok.is(tok::kw___unaligned)) {
3950     ParseMicrosoftTypeAttributes(attrs);
3951   }
3952   // Eat any Borland extensions.
3953   if  (Tok.is(tok::kw___pascal))
3954     ParseBorlandTypeAttributes(attrs);
3955
3956   // If we haven't past the identifier yet (or where the identifier would be
3957   // stored, if this is an abstract declarator), then this is probably just
3958   // grouping parens. However, if this could be an abstract-declarator, then
3959   // this could also be the start of function arguments (consider 'void()').
3960   bool isGrouping;
3961
3962   if (!D.mayOmitIdentifier()) {
3963     // If this can't be an abstract-declarator, this *must* be a grouping
3964     // paren, because we haven't seen the identifier yet.
3965     isGrouping = true;
3966   } else if (Tok.is(tok::r_paren) ||           // 'int()' is a function.
3967              (getLang().CPlusPlus && Tok.is(tok::ellipsis)) || // C++ int(...)
3968              isDeclarationSpecifier()) {       // 'int(int)' is a function.
3969     // This handles C99 6.7.5.3p11: in "typedef int X; void foo(X)", X is
3970     // considered to be a type, not a K&R identifier-list.
3971     isGrouping = false;
3972   } else {
3973     // Otherwise, this is a grouping paren, e.g. 'int (*X)' or 'int(X)'.
3974     isGrouping = true;
3975   }
3976
3977   // If this is a grouping paren, handle:
3978   // direct-declarator: '(' declarator ')'
3979   // direct-declarator: '(' attributes declarator ')'
3980   if (isGrouping) {
3981     bool hadGroupingParens = D.hasGroupingParens();
3982     D.setGroupingParens(true);
3983
3984     ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
3985     // Match the ')'.
3986     T.consumeClose();
3987     D.AddTypeInfo(DeclaratorChunk::getParen(T.getOpenLocation(),
3988                                             T.getCloseLocation()),
3989                   attrs, T.getCloseLocation());
3990
3991     D.setGroupingParens(hadGroupingParens);
3992     return;
3993   }
3994
3995   // Okay, if this wasn't a grouping paren, it must be the start of a function
3996   // argument list.  Recognize that this declarator will never have an
3997   // identifier (and remember where it would have been), then call into
3998   // ParseFunctionDeclarator to handle of argument list.
3999   D.SetIdentifier(0, Tok.getLocation());
4000
4001   ParseFunctionDeclarator(D, attrs, T, RequiresArg);
4002 }
4003
4004 /// ParseFunctionDeclarator - We are after the identifier and have parsed the
4005 /// declarator D up to a paren, which indicates that we are parsing function
4006 /// arguments.
4007 ///
4008 /// If attrs is non-null, then the caller parsed those arguments immediately
4009 /// after the open paren - they should be considered to be the first argument of
4010 /// a parameter.  If RequiresArg is true, then the first argument of the
4011 /// function is required to be present and required to not be an identifier
4012 /// list.
4013 ///
4014 /// For C++, after the parameter-list, it also parses cv-qualifier-seq[opt],
4015 /// (C++0x) ref-qualifier[opt], exception-specification[opt], and
4016 /// (C++0x) trailing-return-type[opt].
4017 ///
4018 /// [C++0x] exception-specification:
4019 ///           dynamic-exception-specification
4020 ///           noexcept-specification
4021 ///
4022 void Parser::ParseFunctionDeclarator(Declarator &D,
4023                                      ParsedAttributes &attrs,
4024                                      BalancedDelimiterTracker &Tracker,
4025                                      bool RequiresArg) {
4026   // lparen is already consumed!
4027   assert(D.isPastIdentifier() && "Should not call before identifier!");
4028
4029   // This should be true when the function has typed arguments.
4030   // Otherwise, it is treated as a K&R-style function.
4031   bool HasProto = false;
4032   // Build up an array of information about the parsed arguments.
4033   SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
4034   // Remember where we see an ellipsis, if any.
4035   SourceLocation EllipsisLoc;
4036
4037   DeclSpec DS(AttrFactory);
4038   bool RefQualifierIsLValueRef = true;
4039   SourceLocation RefQualifierLoc;
4040   ExceptionSpecificationType ESpecType = EST_None;
4041   SourceRange ESpecRange;
4042   SmallVector<ParsedType, 2> DynamicExceptions;
4043   SmallVector<SourceRange, 2> DynamicExceptionRanges;
4044   ExprResult NoexceptExpr;
4045   ParsedType TrailingReturnType;
4046
4047   SourceLocation EndLoc;
4048   if (isFunctionDeclaratorIdentifierList()) {
4049     if (RequiresArg)
4050       Diag(Tok, diag::err_argument_required_after_attribute);
4051
4052     ParseFunctionDeclaratorIdentifierList(D, ParamInfo);
4053
4054     Tracker.consumeClose();
4055     EndLoc = Tracker.getCloseLocation();
4056   } else {
4057     // Enter function-declaration scope, limiting any declarators to the
4058     // function prototype scope, including parameter declarators.
4059     ParseScope PrototypeScope(this,
4060                               Scope::FunctionPrototypeScope|Scope::DeclScope);
4061
4062     if (Tok.isNot(tok::r_paren))
4063       ParseParameterDeclarationClause(D, attrs, ParamInfo, EllipsisLoc);
4064     else if (RequiresArg)
4065       Diag(Tok, diag::err_argument_required_after_attribute);
4066
4067     HasProto = ParamInfo.size() || getLang().CPlusPlus;
4068
4069     // If we have the closing ')', eat it.
4070     Tracker.consumeClose();
4071     EndLoc = Tracker.getCloseLocation();
4072
4073     if (getLang().CPlusPlus) {
4074       MaybeParseCXX0XAttributes(attrs);
4075
4076       // Parse cv-qualifier-seq[opt].
4077       ParseTypeQualifierListOpt(DS, false /*no attributes*/);
4078         if (!DS.getSourceRange().getEnd().isInvalid())
4079           EndLoc = DS.getSourceRange().getEnd();
4080
4081       // Parse ref-qualifier[opt].
4082       if (Tok.is(tok::amp) || Tok.is(tok::ampamp)) {
4083         if (!getLang().CPlusPlus0x)
4084           Diag(Tok, diag::ext_ref_qualifier);
4085
4086         RefQualifierIsLValueRef = Tok.is(tok::amp);
4087         RefQualifierLoc = ConsumeToken();
4088         EndLoc = RefQualifierLoc;
4089       }
4090
4091       // Parse exception-specification[opt].
4092       ESpecType = MaybeParseExceptionSpecification(ESpecRange,
4093                                                    DynamicExceptions,
4094                                                    DynamicExceptionRanges,
4095                                                    NoexceptExpr);
4096       if (ESpecType != EST_None)
4097         EndLoc = ESpecRange.getEnd();
4098
4099       // Parse trailing-return-type[opt].
4100       if (getLang().CPlusPlus0x && Tok.is(tok::arrow)) {
4101         SourceRange Range;
4102         TrailingReturnType = ParseTrailingReturnType(Range).get();
4103         if (Range.getEnd().isValid())
4104           EndLoc = Range.getEnd();
4105       }
4106     }
4107
4108     // Leave prototype scope.
4109     PrototypeScope.Exit();
4110   }
4111
4112   // Remember that we parsed a function type, and remember the attributes.
4113   D.AddTypeInfo(DeclaratorChunk::getFunction(HasProto,
4114                                              /*isVariadic=*/EllipsisLoc.isValid(),
4115                                              EllipsisLoc,
4116                                              ParamInfo.data(), ParamInfo.size(),
4117                                              DS.getTypeQualifiers(),
4118                                              RefQualifierIsLValueRef,
4119                                              RefQualifierLoc,
4120                                              /*MutableLoc=*/SourceLocation(),
4121                                              ESpecType, ESpecRange.getBegin(),
4122                                              DynamicExceptions.data(),
4123                                              DynamicExceptionRanges.data(),
4124                                              DynamicExceptions.size(),
4125                                              NoexceptExpr.isUsable() ?
4126                                                NoexceptExpr.get() : 0,
4127                                              Tracker.getOpenLocation(),
4128                                              EndLoc, D,
4129                                              TrailingReturnType),
4130                 attrs, EndLoc);
4131 }
4132
4133 /// isFunctionDeclaratorIdentifierList - This parameter list may have an
4134 /// identifier list form for a K&R-style function:  void foo(a,b,c)
4135 ///
4136 /// Note that identifier-lists are only allowed for normal declarators, not for
4137 /// abstract-declarators.
4138 bool Parser::isFunctionDeclaratorIdentifierList() {
4139   return !getLang().CPlusPlus
4140          && Tok.is(tok::identifier)
4141          && !TryAltiVecVectorToken()
4142          // K&R identifier lists can't have typedefs as identifiers, per C99
4143          // 6.7.5.3p11.
4144          && (TryAnnotateTypeOrScopeToken() || !Tok.is(tok::annot_typename))
4145          // Identifier lists follow a really simple grammar: the identifiers can
4146          // be followed *only* by a ", identifier" or ")".  However, K&R
4147          // identifier lists are really rare in the brave new modern world, and
4148          // it is very common for someone to typo a type in a non-K&R style
4149          // list.  If we are presented with something like: "void foo(intptr x,
4150          // float y)", we don't want to start parsing the function declarator as
4151          // though it is a K&R style declarator just because intptr is an
4152          // invalid type.
4153          //
4154          // To handle this, we check to see if the token after the first
4155          // identifier is a "," or ")".  Only then do we parse it as an
4156          // identifier list.
4157          && (NextToken().is(tok::comma) || NextToken().is(tok::r_paren));
4158 }
4159
4160 /// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator
4161 /// we found a K&R-style identifier list instead of a typed parameter list.
4162 ///
4163 /// After returning, ParamInfo will hold the parsed parameters.
4164 ///
4165 ///       identifier-list: [C99 6.7.5]
4166 ///         identifier
4167 ///         identifier-list ',' identifier
4168 ///
4169 void Parser::ParseFunctionDeclaratorIdentifierList(
4170        Declarator &D,
4171        SmallVector<DeclaratorChunk::ParamInfo, 16> &ParamInfo) {
4172   // If there was no identifier specified for the declarator, either we are in
4173   // an abstract-declarator, or we are in a parameter declarator which was found
4174   // to be abstract.  In abstract-declarators, identifier lists are not valid:
4175   // diagnose this.
4176   if (!D.getIdentifier())
4177     Diag(Tok, diag::ext_ident_list_in_param);
4178
4179   // Maintain an efficient lookup of params we have seen so far.
4180   llvm::SmallSet<const IdentifierInfo*, 16> ParamsSoFar;
4181
4182   while (1) {
4183     // If this isn't an identifier, report the error and skip until ')'.
4184     if (Tok.isNot(tok::identifier)) {
4185       Diag(Tok, diag::err_expected_ident);
4186       SkipUntil(tok::r_paren, /*StopAtSemi=*/true, /*DontConsume=*/true);
4187       // Forget we parsed anything.
4188       ParamInfo.clear();
4189       return;
4190     }
4191
4192     IdentifierInfo *ParmII = Tok.getIdentifierInfo();
4193
4194     // Reject 'typedef int y; int test(x, y)', but continue parsing.
4195     if (Actions.getTypeName(*ParmII, Tok.getLocation(), getCurScope()))
4196       Diag(Tok, diag::err_unexpected_typedef_ident) << ParmII;
4197
4198     // Verify that the argument identifier has not already been mentioned.
4199     if (!ParamsSoFar.insert(ParmII)) {
4200       Diag(Tok, diag::err_param_redefinition) << ParmII;
4201     } else {
4202       // Remember this identifier in ParamInfo.
4203       ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
4204                                                      Tok.getLocation(),
4205                                                      0));
4206     }
4207
4208     // Eat the identifier.
4209     ConsumeToken();
4210
4211     // The list continues if we see a comma.
4212     if (Tok.isNot(tok::comma))
4213       break;
4214     ConsumeToken();
4215   }
4216 }
4217
4218 /// ParseParameterDeclarationClause - Parse a (possibly empty) parameter-list
4219 /// after the opening parenthesis. This function will not parse a K&R-style
4220 /// identifier list.
4221 ///
4222 /// D is the declarator being parsed.  If attrs is non-null, then the caller
4223 /// parsed those arguments immediately after the open paren - they should be
4224 /// considered to be the first argument of a parameter.
4225 ///
4226 /// After returning, ParamInfo will hold the parsed parameters. EllipsisLoc will
4227 /// be the location of the ellipsis, if any was parsed.
4228 ///
4229 ///       parameter-type-list: [C99 6.7.5]
4230 ///         parameter-list
4231 ///         parameter-list ',' '...'
4232 /// [C++]   parameter-list '...'
4233 ///
4234 ///       parameter-list: [C99 6.7.5]
4235 ///         parameter-declaration
4236 ///         parameter-list ',' parameter-declaration
4237 ///
4238 ///       parameter-declaration: [C99 6.7.5]
4239 ///         declaration-specifiers declarator
4240 /// [C++]   declaration-specifiers declarator '=' assignment-expression
4241 /// [GNU]   declaration-specifiers declarator attributes
4242 ///         declaration-specifiers abstract-declarator[opt]
4243 /// [C++]   declaration-specifiers abstract-declarator[opt]
4244 ///           '=' assignment-expression
4245 /// [GNU]   declaration-specifiers abstract-declarator[opt] attributes
4246 ///
4247 void Parser::ParseParameterDeclarationClause(
4248        Declarator &D,
4249        ParsedAttributes &attrs,
4250        SmallVector<DeclaratorChunk::ParamInfo, 16> &ParamInfo,
4251        SourceLocation &EllipsisLoc) {
4252
4253   while (1) {
4254     if (Tok.is(tok::ellipsis)) {
4255       EllipsisLoc = ConsumeToken();     // Consume the ellipsis.
4256       break;
4257     }
4258
4259     // Parse the declaration-specifiers.
4260     // Just use the ParsingDeclaration "scope" of the declarator.
4261     DeclSpec DS(AttrFactory);
4262
4263     // Skip any Microsoft attributes before a param.
4264     if (getLang().MicrosoftExt && Tok.is(tok::l_square))
4265       ParseMicrosoftAttributes(DS.getAttributes());
4266
4267     SourceLocation DSStart = Tok.getLocation();
4268
4269     // If the caller parsed attributes for the first argument, add them now.
4270     // Take them so that we only apply the attributes to the first parameter.
4271     // FIXME: If we saw an ellipsis first, this code is not reached. Are the
4272     // attributes lost? Should they even be allowed?
4273     // FIXME: If we can leave the attributes in the token stream somehow, we can
4274     // get rid of a parameter (attrs) and this statement. It might be too much
4275     // hassle.
4276     DS.takeAttributesFrom(attrs);
4277
4278     ParseDeclarationSpecifiers(DS);
4279
4280     // Parse the declarator.  This is "PrototypeContext", because we must
4281     // accept either 'declarator' or 'abstract-declarator' here.
4282     Declarator ParmDecl(DS, Declarator::PrototypeContext);
4283     ParseDeclarator(ParmDecl);
4284
4285     // Parse GNU attributes, if present.
4286     MaybeParseGNUAttributes(ParmDecl);
4287
4288     // Remember this parsed parameter in ParamInfo.
4289     IdentifierInfo *ParmII = ParmDecl.getIdentifier();
4290
4291     // DefArgToks is used when the parsing of default arguments needs
4292     // to be delayed.
4293     CachedTokens *DefArgToks = 0;
4294
4295     // If no parameter was specified, verify that *something* was specified,
4296     // otherwise we have a missing type and identifier.
4297     if (DS.isEmpty() && ParmDecl.getIdentifier() == 0 &&
4298         ParmDecl.getNumTypeObjects() == 0) {
4299       // Completely missing, emit error.
4300       Diag(DSStart, diag::err_missing_param);
4301     } else {
4302       // Otherwise, we have something.  Add it and let semantic analysis try
4303       // to grok it and add the result to the ParamInfo we are building.
4304
4305       // Inform the actions module about the parameter declarator, so it gets
4306       // added to the current scope.
4307       Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl);
4308
4309       // Parse the default argument, if any. We parse the default
4310       // arguments in all dialects; the semantic analysis in
4311       // ActOnParamDefaultArgument will reject the default argument in
4312       // C.
4313       if (Tok.is(tok::equal)) {
4314         SourceLocation EqualLoc = Tok.getLocation();
4315
4316         // Parse the default argument
4317         if (D.getContext() == Declarator::MemberContext) {
4318           // If we're inside a class definition, cache the tokens
4319           // corresponding to the default argument. We'll actually parse
4320           // them when we see the end of the class definition.
4321           // FIXME: Templates will require something similar.
4322           // FIXME: Can we use a smart pointer for Toks?
4323           DefArgToks = new CachedTokens;
4324
4325           if (!ConsumeAndStoreUntil(tok::comma, tok::r_paren, *DefArgToks,
4326                                     /*StopAtSemi=*/true,
4327                                     /*ConsumeFinalToken=*/false)) {
4328             delete DefArgToks;
4329             DefArgToks = 0;
4330             Actions.ActOnParamDefaultArgumentError(Param);
4331           } else {
4332             // Mark the end of the default argument so that we know when to
4333             // stop when we parse it later on.
4334             Token DefArgEnd;
4335             DefArgEnd.startToken();
4336             DefArgEnd.setKind(tok::cxx_defaultarg_end);
4337             DefArgEnd.setLocation(Tok.getLocation());
4338             DefArgToks->push_back(DefArgEnd);
4339             Actions.ActOnParamUnparsedDefaultArgument(Param, EqualLoc,
4340                                                 (*DefArgToks)[1].getLocation());
4341           }
4342         } else {
4343           // Consume the '='.
4344           ConsumeToken();
4345
4346           // The argument isn't actually potentially evaluated unless it is
4347           // used.
4348           EnterExpressionEvaluationContext Eval(Actions,
4349                                               Sema::PotentiallyEvaluatedIfUsed);
4350
4351           ExprResult DefArgResult(ParseAssignmentExpression());
4352           if (DefArgResult.isInvalid()) {
4353             Actions.ActOnParamDefaultArgumentError(Param);
4354             SkipUntil(tok::comma, tok::r_paren, true, true);
4355           } else {
4356             // Inform the actions module about the default argument
4357             Actions.ActOnParamDefaultArgument(Param, EqualLoc,
4358                                               DefArgResult.take());
4359           }
4360         }
4361       }
4362
4363       ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
4364                                           ParmDecl.getIdentifierLoc(), Param,
4365                                           DefArgToks));
4366     }
4367
4368     // If the next token is a comma, consume it and keep reading arguments.
4369     if (Tok.isNot(tok::comma)) {
4370       if (Tok.is(tok::ellipsis)) {
4371         EllipsisLoc = ConsumeToken();     // Consume the ellipsis.
4372
4373         if (!getLang().CPlusPlus) {
4374           // We have ellipsis without a preceding ',', which is ill-formed
4375           // in C. Complain and provide the fix.
4376           Diag(EllipsisLoc, diag::err_missing_comma_before_ellipsis)
4377             << FixItHint::CreateInsertion(EllipsisLoc, ", ");
4378         }
4379       }
4380
4381       break;
4382     }
4383
4384     // Consume the comma.
4385     ConsumeToken();
4386   }
4387
4388 }
4389
4390 /// [C90]   direct-declarator '[' constant-expression[opt] ']'
4391 /// [C99]   direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
4392 /// [C99]   direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
4393 /// [C99]   direct-declarator '[' type-qual-list 'static' assignment-expr ']'
4394 /// [C99]   direct-declarator '[' type-qual-list[opt] '*' ']'
4395 void Parser::ParseBracketDeclarator(Declarator &D) {
4396   BalancedDelimiterTracker T(*this, tok::l_square);
4397   T.consumeOpen();
4398
4399   // C array syntax has many features, but by-far the most common is [] and [4].
4400   // This code does a fast path to handle some of the most obvious cases.
4401   if (Tok.getKind() == tok::r_square) {
4402     T.consumeClose();
4403     ParsedAttributes attrs(AttrFactory);
4404     MaybeParseCXX0XAttributes(attrs);
4405
4406     // Remember that we parsed the empty array type.
4407     ExprResult NumElements;
4408     D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, 0,
4409                                             T.getOpenLocation(),
4410                                             T.getCloseLocation()),
4411                   attrs, T.getCloseLocation());
4412     return;
4413   } else if (Tok.getKind() == tok::numeric_constant &&
4414              GetLookAheadToken(1).is(tok::r_square)) {
4415     // [4] is very common.  Parse the numeric constant expression.
4416     ExprResult ExprRes(Actions.ActOnNumericConstant(Tok));
4417     ConsumeToken();
4418
4419     T.consumeClose();
4420     ParsedAttributes attrs(AttrFactory);
4421     MaybeParseCXX0XAttributes(attrs);
4422
4423     // Remember that we parsed a array type, and remember its features.
4424     D.AddTypeInfo(DeclaratorChunk::getArray(0, false, 0,
4425                                             ExprRes.release(),
4426                                             T.getOpenLocation(),
4427                                             T.getCloseLocation()),
4428                   attrs, T.getCloseLocation());
4429     return;
4430   }
4431
4432   // If valid, this location is the position where we read the 'static' keyword.
4433   SourceLocation StaticLoc;
4434   if (Tok.is(tok::kw_static))
4435     StaticLoc = ConsumeToken();
4436
4437   // If there is a type-qualifier-list, read it now.
4438   // Type qualifiers in an array subscript are a C99 feature.
4439   DeclSpec DS(AttrFactory);
4440   ParseTypeQualifierListOpt(DS, false /*no attributes*/);
4441
4442   // If we haven't already read 'static', check to see if there is one after the
4443   // type-qualifier-list.
4444   if (!StaticLoc.isValid() && Tok.is(tok::kw_static))
4445     StaticLoc = ConsumeToken();
4446
4447   // Handle "direct-declarator [ type-qual-list[opt] * ]".
4448   bool isStar = false;
4449   ExprResult NumElements;
4450
4451   // Handle the case where we have '[*]' as the array size.  However, a leading
4452   // star could be the start of an expression, for example 'X[*p + 4]'.  Verify
4453   // the the token after the star is a ']'.  Since stars in arrays are
4454   // infrequent, use of lookahead is not costly here.
4455   if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) {
4456     ConsumeToken();  // Eat the '*'.
4457
4458     if (StaticLoc.isValid()) {
4459       Diag(StaticLoc, diag::err_unspecified_vla_size_with_static);
4460       StaticLoc = SourceLocation();  // Drop the static.
4461     }
4462     isStar = true;
4463   } else if (Tok.isNot(tok::r_square)) {
4464     // Note, in C89, this production uses the constant-expr production instead
4465     // of assignment-expr.  The only difference is that assignment-expr allows
4466     // things like '=' and '*='.  Sema rejects these in C89 mode because they
4467     // are not i-c-e's, so we don't need to distinguish between the two here.
4468
4469     // Parse the constant-expression or assignment-expression now (depending
4470     // on dialect).
4471     if (getLang().CPlusPlus)
4472       NumElements = ParseConstantExpression();
4473     else
4474       NumElements = ParseAssignmentExpression();
4475   }
4476
4477   // If there was an error parsing the assignment-expression, recover.
4478   if (NumElements.isInvalid()) {
4479     D.setInvalidType(true);
4480     // If the expression was invalid, skip it.
4481     SkipUntil(tok::r_square);
4482     return;
4483   }
4484
4485   T.consumeClose();
4486
4487   ParsedAttributes attrs(AttrFactory);
4488   MaybeParseCXX0XAttributes(attrs);
4489
4490   // Remember that we parsed a array type, and remember its features.
4491   D.AddTypeInfo(DeclaratorChunk::getArray(DS.getTypeQualifiers(),
4492                                           StaticLoc.isValid(), isStar,
4493                                           NumElements.release(),
4494                                           T.getOpenLocation(),
4495                                           T.getCloseLocation()),
4496                 attrs, T.getCloseLocation());
4497 }
4498
4499 /// [GNU]   typeof-specifier:
4500 ///           typeof ( expressions )
4501 ///           typeof ( type-name )
4502 /// [GNU/C++] typeof unary-expression
4503 ///
4504 void Parser::ParseTypeofSpecifier(DeclSpec &DS) {
4505   assert(Tok.is(tok::kw_typeof) && "Not a typeof specifier");
4506   Token OpTok = Tok;
4507   SourceLocation StartLoc = ConsumeToken();
4508
4509   const bool hasParens = Tok.is(tok::l_paren);
4510
4511   bool isCastExpr;
4512   ParsedType CastTy;
4513   SourceRange CastRange;
4514   ExprResult Operand = ParseExprAfterUnaryExprOrTypeTrait(OpTok, isCastExpr,
4515                                                           CastTy, CastRange);
4516   if (hasParens)
4517     DS.setTypeofParensRange(CastRange);
4518
4519   if (CastRange.getEnd().isInvalid())
4520     // FIXME: Not accurate, the range gets one token more than it should.
4521     DS.SetRangeEnd(Tok.getLocation());
4522   else
4523     DS.SetRangeEnd(CastRange.getEnd());
4524
4525   if (isCastExpr) {
4526     if (!CastTy) {
4527       DS.SetTypeSpecError();
4528       return;
4529     }
4530
4531     const char *PrevSpec = 0;
4532     unsigned DiagID;
4533     // Check for duplicate type specifiers (e.g. "int typeof(int)").
4534     if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec,
4535                            DiagID, CastTy))
4536       Diag(StartLoc, DiagID) << PrevSpec;
4537     return;
4538   }
4539
4540   // If we get here, the operand to the typeof was an expresion.
4541   if (Operand.isInvalid()) {
4542     DS.SetTypeSpecError();
4543     return;
4544   }
4545
4546   const char *PrevSpec = 0;
4547   unsigned DiagID;
4548   // Check for duplicate type specifiers (e.g. "int typeof(int)").
4549   if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec,
4550                          DiagID, Operand.get()))
4551     Diag(StartLoc, DiagID) << PrevSpec;
4552 }
4553
4554 /// [C1X]   atomic-specifier:
4555 ///           _Atomic ( type-name )
4556 ///
4557 void Parser::ParseAtomicSpecifier(DeclSpec &DS) {
4558   assert(Tok.is(tok::kw__Atomic) && "Not an atomic specifier");
4559
4560   SourceLocation StartLoc = ConsumeToken();
4561   BalancedDelimiterTracker T(*this, tok::l_paren);
4562   if (T.expectAndConsume(diag::err_expected_lparen_after, "_Atomic")) {
4563     SkipUntil(tok::r_paren);
4564     return;
4565   }
4566
4567   TypeResult Result = ParseTypeName();
4568   if (Result.isInvalid()) {
4569     SkipUntil(tok::r_paren);
4570     return;
4571   }
4572
4573   // Match the ')'
4574   T.consumeClose();
4575
4576   if (T.getCloseLocation().isInvalid())
4577     return;
4578
4579   DS.setTypeofParensRange(T.getRange());
4580   DS.SetRangeEnd(T.getCloseLocation());
4581
4582   const char *PrevSpec = 0;
4583   unsigned DiagID;
4584   if (DS.SetTypeSpecType(DeclSpec::TST_atomic, StartLoc, PrevSpec,
4585                          DiagID, Result.release()))
4586     Diag(StartLoc, DiagID) << PrevSpec;
4587 }
4588
4589
4590 /// TryAltiVecVectorTokenOutOfLine - Out of line body that should only be called
4591 /// from TryAltiVecVectorToken.
4592 bool Parser::TryAltiVecVectorTokenOutOfLine() {
4593   Token Next = NextToken();
4594   switch (Next.getKind()) {
4595   default: return false;
4596   case tok::kw_short:
4597   case tok::kw_long:
4598   case tok::kw_signed:
4599   case tok::kw_unsigned:
4600   case tok::kw_void:
4601   case tok::kw_char:
4602   case tok::kw_int:
4603   case tok::kw_float:
4604   case tok::kw_double:
4605   case tok::kw_bool:
4606   case tok::kw___pixel:
4607     Tok.setKind(tok::kw___vector);
4608     return true;
4609   case tok::identifier:
4610     if (Next.getIdentifierInfo() == Ident_pixel) {
4611       Tok.setKind(tok::kw___vector);
4612       return true;
4613     }
4614     return false;
4615   }
4616 }
4617
4618 bool Parser::TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc,
4619                                       const char *&PrevSpec, unsigned &DiagID,
4620                                       bool &isInvalid) {
4621   if (Tok.getIdentifierInfo() == Ident_vector) {
4622     Token Next = NextToken();
4623     switch (Next.getKind()) {
4624     case tok::kw_short:
4625     case tok::kw_long:
4626     case tok::kw_signed:
4627     case tok::kw_unsigned:
4628     case tok::kw_void:
4629     case tok::kw_char:
4630     case tok::kw_int:
4631     case tok::kw_float:
4632     case tok::kw_double:
4633     case tok::kw_bool:
4634     case tok::kw___pixel:
4635       isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
4636       return true;
4637     case tok::identifier:
4638       if (Next.getIdentifierInfo() == Ident_pixel) {
4639         isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
4640         return true;
4641       }
4642       break;
4643     default:
4644       break;
4645     }
4646   } else if ((Tok.getIdentifierInfo() == Ident_pixel) &&
4647              DS.isTypeAltiVecVector()) {
4648     isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID);
4649     return true;
4650   }
4651   return false;
4652 }