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

   1 //===--- ParseTentative.cpp - Ambiguity Resolution 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 tentative parsing portions of the Parser
  11 //  interfaces, for ambiguity resolution.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Parse/Parser.h"
  16 #include "clang/Parse/ParseDiagnostic.h"
  17 #include "clang/Sema/ParsedTemplate.h"
  18 using namespace clang;
  19
  20 /// isCXXDeclarationStatement - C++-specialized function that disambiguates
  21 /// between a declaration or an expression statement, when parsing function
  22 /// bodies. Returns true for declaration, false for expression.
  23 ///
  24 ///         declaration-statement:
  25 ///           block-declaration
  26 ///
  27 ///         block-declaration:
  28 ///           simple-declaration
  29 ///           asm-definition
  30 ///           namespace-alias-definition
  31 ///           using-declaration
  32 ///           using-directive
  33 /// [C++0x]   static_assert-declaration
  34 ///
  35 ///         asm-definition:
  36 ///           'asm' '(' string-literal ')' ';'
  37 ///
  38 ///         namespace-alias-definition:
  39 ///           'namespace' identifier = qualified-namespace-specifier ';'
  40 ///
  41 ///         using-declaration:
  42 ///           'using' typename[opt] '::'[opt] nested-name-specifier
  43 ///                 unqualified-id ';'
  44 ///           'using' '::' unqualified-id ;
  45 ///
  46 ///         using-directive:
  47 ///           'using' 'namespace' '::'[opt] nested-name-specifier[opt]
  48 ///                 namespace-name ';'
  49 ///
  50 bool Parser::isCXXDeclarationStatement() {
  51   switch (Tok.getKind()) {
  52     // asm-definition
  53   case tok::kw_asm:
  54     // namespace-alias-definition
  55   case tok::kw_namespace:
  56     // using-declaration
  57     // using-directive
  58   case tok::kw_using:
  59     // static_assert-declaration
  60   case tok::kw_static_assert:
  61   case tok::kw__Static_assert:
  62     return true;
  63     // simple-declaration
  64   default:
  65     return isCXXSimpleDeclaration();
  66   }
  67 }
  68
  69 /// isCXXSimpleDeclaration - C++-specialized function that disambiguates
  70 /// between a simple-declaration or an expression-statement.
  71 /// If during the disambiguation process a parsing error is encountered,
  72 /// the function returns true to let the declaration parsing code handle it.
  73 /// Returns false if the statement is disambiguated as expression.
  74 ///
  75 /// simple-declaration:
  76 ///   decl-specifier-seq init-declarator-list[opt] ';'
  77 ///
  78 bool Parser::isCXXSimpleDeclaration() {
  79   // C++ 6.8p1:
  80   // There is an ambiguity in the grammar involving expression-statements and
  81   // declarations: An expression-statement with a function-style explicit type
  82   // conversion (5.2.3) as its leftmost subexpression can be indistinguishable
  83   // from a declaration where the first declarator starts with a '('. In those
  84   // cases the statement is a declaration. [Note: To disambiguate, the whole
  85   // statement might have to be examined to determine if it is an
  86   // expression-statement or a declaration].
  87
  88   // C++ 6.8p3:
  89   // The disambiguation is purely syntactic; that is, the meaning of the names
  90   // occurring in such a statement, beyond whether they are type-names or not,
  91   // is not generally used in or changed by the disambiguation. Class
  92   // templates are instantiated as necessary to determine if a qualified name
  93   // is a type-name. Disambiguation precedes parsing, and a statement
  94   // disambiguated as a declaration may be an ill-formed declaration.
  95
  96   // We don't have to parse all of the decl-specifier-seq part. There's only
  97   // an ambiguity if the first decl-specifier is
  98   // simple-type-specifier/typename-specifier followed by a '(', which may
  99   // indicate a function-style cast expression.
 100   // isCXXDeclarationSpecifier will return TPResult::Ambiguous() only in such
 101   // a case.
 102
 103   TPResult TPR = isCXXDeclarationSpecifier();
 104   if (TPR != TPResult::Ambiguous())
 105     return TPR != TPResult::False(); // Returns true for TPResult::True() or
 106                                      // TPResult::Error().
 107
 108   // FIXME: Add statistics about the number of ambiguous statements encountered
 109   // and how they were resolved (number of declarations+number of expressions).
 110
 111   // Ok, we have a simple-type-specifier/typename-specifier followed by a '('.
 112   // We need tentative parsing...
 113
 114   TentativeParsingAction PA(*this);
 115   TPR = TryParseSimpleDeclaration();
 116   PA.Revert();
 117
 118   // In case of an error, let the declaration parsing code handle it.
 119   if (TPR == TPResult::Error())
 120     return true;
 121
 122   // Declarations take precedence over expressions.
 123   if (TPR == TPResult::Ambiguous())
 124     TPR = TPResult::True();
 125
 126   assert(TPR == TPResult::True() || TPR == TPResult::False());
 127   return TPR == TPResult::True();
 128 }
 129
 130 /// simple-declaration:
 131 ///   decl-specifier-seq init-declarator-list[opt] ';'
 132 ///
 133 Parser::TPResult Parser::TryParseSimpleDeclaration() {
 134   // We know that we have a simple-type-specifier/typename-specifier followed
 135   // by a '('.
 136   assert(isCXXDeclarationSpecifier() == TPResult::Ambiguous());
 137
 138   if (Tok.is(tok::kw_typeof))
 139     TryParseTypeofSpecifier();
 140   else {
 141     ConsumeToken();
 142
 143     if (getLang().ObjC1 && Tok.is(tok::less))
 144       TryParseProtocolQualifiers();
 145   }
 146
 147   assert(Tok.is(tok::l_paren) && "Expected '('");
 148
 149   TPResult TPR = TryParseInitDeclaratorList();
 150   if (TPR != TPResult::Ambiguous())
 151     return TPR;
 152
 153   if (Tok.isNot(tok::semi))
 154     return TPResult::False();
 155
 156   return TPResult::Ambiguous();
 157 }
 158
 159 ///       init-declarator-list:
 160 ///         init-declarator
 161 ///         init-declarator-list ',' init-declarator
 162 ///
 163 ///       init-declarator:
 164 ///         declarator initializer[opt]
 165 /// [GNU]   declarator simple-asm-expr[opt] attributes[opt] initializer[opt]
 166 ///
 167 /// initializer:
 168 ///   '=' initializer-clause
 169 ///   '(' expression-list ')'
 170 ///
 171 /// initializer-clause:
 172 ///   assignment-expression
 173 ///   '{' initializer-list ','[opt] '}'
 174 ///   '{' '}'
 175 ///
 176 Parser::TPResult Parser::TryParseInitDeclaratorList() {
 177   while (1) {
 178     // declarator
 179     TPResult TPR = TryParseDeclarator(false/*mayBeAbstract*/);
 180     if (TPR != TPResult::Ambiguous())
 181       return TPR;
 182
 183     // [GNU] simple-asm-expr[opt] attributes[opt]
 184     if (Tok.is(tok::kw_asm) || Tok.is(tok::kw___attribute))
 185       return TPResult::True();
 186
 187     // initializer[opt]
 188     if (Tok.is(tok::l_paren)) {
 189       // Parse through the parens.
 190       ConsumeParen();
 191       if (!SkipUntil(tok::r_paren))
 192         return TPResult::Error();
 193     } else if (Tok.is(tok::equal) || isTokIdentifier_in()) {
 194       // MSVC and g++ won't examine the rest of declarators if '=' is
 195       // encountered; they just conclude that we have a declaration.
 196       // EDG parses the initializer completely, which is the proper behavior
 197       // for this case.
 198       //
 199       // At present, Clang follows MSVC and g++, since the parser does not have
 200       // the ability to parse an expression fully without recording the
 201       // results of that parse.
 202       // Also allow 'in' after on objective-c declaration as in:
 203       // for (int (^b)(void) in array). Ideally this should be done in the
 204       // context of parsing for-init-statement of a foreach statement only. But,
 205       // in any other context 'in' is invalid after a declaration and parser
 206       // issues the error regardless of outcome of this decision.
 207       // FIXME. Change if above assumption does not hold.
 208       return TPResult::True();
 209     }
 210
 211     if (Tok.isNot(tok::comma))
 212       break;
 213     ConsumeToken(); // the comma.
 214   }
 215
 216   return TPResult::Ambiguous();
 217 }
 218
 219 /// isCXXConditionDeclaration - Disambiguates between a declaration or an
 220 /// expression for a condition of a if/switch/while/for statement.
 221 /// If during the disambiguation process a parsing error is encountered,
 222 /// the function returns true to let the declaration parsing code handle it.
 223 ///
 224 ///       condition:
 225 ///         expression
 226 ///         type-specifier-seq declarator '=' assignment-expression
 227 /// [GNU]   type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
 228 ///             '=' assignment-expression
 229 ///
 230 bool Parser::isCXXConditionDeclaration() {
 231   TPResult TPR = isCXXDeclarationSpecifier();
 232   if (TPR != TPResult::Ambiguous())
 233     return TPR != TPResult::False(); // Returns true for TPResult::True() or
 234                                      // TPResult::Error().
 235
 236   // FIXME: Add statistics about the number of ambiguous statements encountered
 237   // and how they were resolved (number of declarations+number of expressions).
 238
 239   // Ok, we have a simple-type-specifier/typename-specifier followed by a '('.
 240   // We need tentative parsing...
 241
 242   TentativeParsingAction PA(*this);
 243
 244   // type-specifier-seq
 245   if (Tok.is(tok::kw_typeof))
 246     TryParseTypeofSpecifier();
 247   else {
 248     ConsumeToken();
 249
 250     if (getLang().ObjC1 && Tok.is(tok::less))
 251       TryParseProtocolQualifiers();
 252   }
 253   assert(Tok.is(tok::l_paren) && "Expected '('");
 254
 255   // declarator
 256   TPR = TryParseDeclarator(false/*mayBeAbstract*/);
 257
 258   // In case of an error, let the declaration parsing code handle it.
 259   if (TPR == TPResult::Error())
 260     TPR = TPResult::True();
 261
 262   if (TPR == TPResult::Ambiguous()) {
 263     // '='
 264     // [GNU] simple-asm-expr[opt] attributes[opt]
 265     if (Tok.is(tok::equal)  ||
 266         Tok.is(tok::kw_asm) || Tok.is(tok::kw___attribute))
 267       TPR = TPResult::True();
 268     else
 269       TPR = TPResult::False();
 270   }
 271
 272   PA.Revert();
 273
 274   assert(TPR == TPResult::True() || TPR == TPResult::False());
 275   return TPR == TPResult::True();
 276 }
 277
 278   /// \brief Determine whether the next set of tokens contains a type-id.
 279   ///
 280   /// The context parameter states what context we're parsing right
 281   /// now, which affects how this routine copes with the token
 282   /// following the type-id. If the context is TypeIdInParens, we have
 283   /// already parsed the '(' and we will cease lookahead when we hit
 284   /// the corresponding ')'. If the context is
 285   /// TypeIdAsTemplateArgument, we've already parsed the '<' or ','
 286   /// before this template argument, and will cease lookahead when we
 287   /// hit a '>', '>>' (in C++0x), or ','. Returns true for a type-id
 288   /// and false for an expression.  If during the disambiguation
 289   /// process a parsing error is encountered, the function returns
 290   /// true to let the declaration parsing code handle it.
 291   ///
 292   /// type-id:
 293   ///   type-specifier-seq abstract-declarator[opt]
 294   ///
 295 bool Parser::isCXXTypeId(TentativeCXXTypeIdContext Context, bool &isAmbiguous) {
 296
 297   isAmbiguous = false;
 298
 299   // C++ 8.2p2:
 300   // The ambiguity arising from the similarity between a function-style cast and
 301   // a type-id can occur in different contexts. The ambiguity appears as a
 302   // choice between a function-style cast expression and a declaration of a
 303   // type. The resolution is that any construct that could possibly be a type-id
 304   // in its syntactic context shall be considered a type-id.
 305
 306   TPResult TPR = isCXXDeclarationSpecifier();
 307   if (TPR != TPResult::Ambiguous())
 308     return TPR != TPResult::False(); // Returns true for TPResult::True() or
 309                                      // TPResult::Error().
 310
 311   // FIXME: Add statistics about the number of ambiguous statements encountered
 312   // and how they were resolved (number of declarations+number of expressions).
 313
 314   // Ok, we have a simple-type-specifier/typename-specifier followed by a '('.
 315   // We need tentative parsing...
 316
 317   TentativeParsingAction PA(*this);
 318
 319   // type-specifier-seq
 320   if (Tok.is(tok::kw_typeof))
 321     TryParseTypeofSpecifier();
 322   else {
 323     ConsumeToken();
 324
 325     if (getLang().ObjC1 && Tok.is(tok::less))
 326       TryParseProtocolQualifiers();
 327   }
 328
 329   assert(Tok.is(tok::l_paren) && "Expected '('");
 330
 331   // declarator
 332   TPR = TryParseDeclarator(true/*mayBeAbstract*/, false/*mayHaveIdentifier*/);
 333
 334   // In case of an error, let the declaration parsing code handle it.
 335   if (TPR == TPResult::Error())
 336     TPR = TPResult::True();
 337
 338   if (TPR == TPResult::Ambiguous()) {
 339     // We are supposed to be inside parens, so if after the abstract declarator
 340     // we encounter a ')' this is a type-id, otherwise it's an expression.
 341     if (Context == TypeIdInParens && Tok.is(tok::r_paren)) {
 342       TPR = TPResult::True();
 343       isAmbiguous = true;
 344
 345     // We are supposed to be inside a template argument, so if after
 346     // the abstract declarator we encounter a '>', '>>' (in C++0x), or
 347     // ',', this is a type-id. Otherwise, it's an expression.
 348     } else if (Context == TypeIdAsTemplateArgument &&
 349                (Tok.is(tok::greater) || Tok.is(tok::comma) ||
 350                 (getLang().CPlusPlus0x && Tok.is(tok::greatergreater)))) {
 351       TPR = TPResult::True();
 352       isAmbiguous = true;
 353
 354     } else
 355       TPR = TPResult::False();
 356   }
 357
 358   PA.Revert();
 359
 360   assert(TPR == TPResult::True() || TPR == TPResult::False());
 361   return TPR == TPResult::True();
 362 }
 363
 364 /// isCXX0XAttributeSpecifier - returns true if this is a C++0x
 365 /// attribute-specifier. By default, unless in Obj-C++, only a cursory check is
 366 /// performed that will simply return true if a [[ is seen. Currently C++ has no
 367 /// syntactical ambiguities from this check, but it may inhibit error recovery.
 368 /// If CheckClosing is true, a check is made for closing ]] brackets.
 369 ///
 370 /// If given, After is set to the token after the attribute-specifier so that
 371 /// appropriate parsing decisions can be made; it is left untouched if false is
 372 /// returned.
 373 ///
 374 /// FIXME: If an error is in the closing ]] brackets, the program assumes
 375 /// the absence of an attribute-specifier, which can cause very yucky errors
 376 /// to occur.
 377 ///
 378 /// [C++0x] attribute-specifier:
 379 ///         '[' '[' attribute-list ']' ']'
 380 ///
 381 /// [C++0x] attribute-list:
 382 ///         attribute[opt]
 383 ///         attribute-list ',' attribute[opt]
 384 ///
 385 /// [C++0x] attribute:
 386 ///         attribute-token attribute-argument-clause[opt]
 387 ///
 388 /// [C++0x] attribute-token:
 389 ///         identifier
 390 ///         attribute-scoped-token
 391 ///
 392 /// [C++0x] attribute-scoped-token:
 393 ///         attribute-namespace '::' identifier
 394 ///
 395 /// [C++0x] attribute-namespace:
 396 ///         identifier
 397 ///
 398 /// [C++0x] attribute-argument-clause:
 399 ///         '(' balanced-token-seq ')'
 400 ///
 401 /// [C++0x] balanced-token-seq:
 402 ///         balanced-token
 403 ///         balanced-token-seq balanced-token
 404 ///
 405 /// [C++0x] balanced-token:
 406 ///         '(' balanced-token-seq ')'
 407 ///         '[' balanced-token-seq ']'
 408 ///         '{' balanced-token-seq '}'
 409 ///         any token but '(', ')', '[', ']', '{', or '}'
 410 bool Parser::isCXX0XAttributeSpecifier (bool CheckClosing,
 411                                         tok::TokenKind *After) {
 412   if (Tok.isNot(tok::l_square) || NextToken().isNot(tok::l_square))
 413     return false;
 414
 415   // No tentative parsing if we don't need to look for ]]
 416   if (!CheckClosing && !getLang().ObjC1)
 417     return true;
 418
 419   struct TentativeReverter {
 420     TentativeParsingAction PA;
 421
 422     TentativeReverter (Parser& P)
 423       : PA(P)
 424     {}
 425     ~TentativeReverter () {
 426       PA.Revert();
 427     }
 428   } R(*this);
 429
 430   // Opening brackets were checked for above.
 431   ConsumeBracket();
 432   ConsumeBracket();
 433
 434   // SkipUntil will handle balanced tokens, which are guaranteed in attributes.
 435   SkipUntil(tok::r_square, false);
 436
 437   if (Tok.isNot(tok::r_square))
 438     return false;
 439   ConsumeBracket();
 440
 441   if (After)
 442     *After = Tok.getKind();
 443
 444   return true;
 445 }
 446
 447 ///         declarator:
 448 ///           direct-declarator
 449 ///           ptr-operator declarator
 450 ///
 451 ///         direct-declarator:
 452 ///           declarator-id
 453 ///           direct-declarator '(' parameter-declaration-clause ')'
 454 ///                 cv-qualifier-seq[opt] exception-specification[opt]
 455 ///           direct-declarator '[' constant-expression[opt] ']'
 456 ///           '(' declarator ')'
 457 /// [GNU]     '(' attributes declarator ')'
 458 ///
 459 ///         abstract-declarator:
 460 ///           ptr-operator abstract-declarator[opt]
 461 ///           direct-abstract-declarator
 462 ///           ...
 463 ///
 464 ///         direct-abstract-declarator:
 465 ///           direct-abstract-declarator[opt]
 466 ///           '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
 467 ///                 exception-specification[opt]
 468 ///           direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
 469 ///           '(' abstract-declarator ')'
 470 ///
 471 ///         ptr-operator:
 472 ///           '*' cv-qualifier-seq[opt]
 473 ///           '&'
 474 /// [C++0x]   '&&'                                                        [TODO]
 475 ///           '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
 476 ///
 477 ///         cv-qualifier-seq:
 478 ///           cv-qualifier cv-qualifier-seq[opt]
 479 ///
 480 ///         cv-qualifier:
 481 ///           'const'
 482 ///           'volatile'
 483 ///
 484 ///         declarator-id:
 485 ///           '...'[opt] id-expression
 486 ///
 487 ///         id-expression:
 488 ///           unqualified-id
 489 ///           qualified-id                                                [TODO]
 490 ///
 491 ///         unqualified-id:
 492 ///           identifier
 493 ///           operator-function-id                                        [TODO]
 494 ///           conversion-function-id                                      [TODO]
 495 ///           '~' class-name                                              [TODO]
 496 ///           template-id                                                 [TODO]
 497 ///
 498 Parser::TPResult Parser::TryParseDeclarator(bool mayBeAbstract,
 499                                             bool mayHaveIdentifier) {
 500   // declarator:
 501   //   direct-declarator
 502   //   ptr-operator declarator
 503
 504   while (1) {
 505     if (Tok.is(tok::coloncolon) || Tok.is(tok::identifier))
 506       if (TryAnnotateCXXScopeToken(true))
 507         return TPResult::Error();
 508
 509     if (Tok.is(tok::star) || Tok.is(tok::amp) || Tok.is(tok::caret) ||
 510         Tok.is(tok::ampamp) ||
 511         (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::star))) {
 512       // ptr-operator
 513       ConsumeToken();
 514       while (Tok.is(tok::kw_const)    ||
 515              Tok.is(tok::kw_volatile) ||
 516              Tok.is(tok::kw_restrict))
 517         ConsumeToken();
 518     } else {
 519       break;
 520     }
 521   }
 522
 523   // direct-declarator:
 524   // direct-abstract-declarator:
 525   if (Tok.is(tok::ellipsis))
 526     ConsumeToken();
 527
 528   if ((Tok.is(tok::identifier) ||
 529        (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier))) &&
 530       mayHaveIdentifier) {
 531     // declarator-id
 532     if (Tok.is(tok::annot_cxxscope))
 533       ConsumeToken();
 534     ConsumeToken();
 535   } else if (Tok.is(tok::l_paren)) {
 536     ConsumeParen();
 537     if (mayBeAbstract &&
 538         (Tok.is(tok::r_paren) ||       // 'int()' is a function.
 539          Tok.is(tok::ellipsis) ||      // 'int(...)' is a function.
 540          isDeclarationSpecifier())) {   // 'int(int)' is a function.
 541       // '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
 542       //        exception-specification[opt]
 543       TPResult TPR = TryParseFunctionDeclarator();
 544       if (TPR != TPResult::Ambiguous())
 545         return TPR;
 546     } else {
 547       // '(' declarator ')'
 548       // '(' attributes declarator ')'
 549       // '(' abstract-declarator ')'
 550       if (Tok.is(tok::kw___attribute) ||
 551           Tok.is(tok::kw___declspec) ||
 552           Tok.is(tok::kw___cdecl) ||
 553           Tok.is(tok::kw___stdcall) ||
 554           Tok.is(tok::kw___fastcall) ||
 555           Tok.is(tok::kw___thiscall))
 556         return TPResult::True(); // attributes indicate declaration
 557       TPResult TPR = TryParseDeclarator(mayBeAbstract, mayHaveIdentifier);
 558       if (TPR != TPResult::Ambiguous())
 559         return TPR;
 560       if (Tok.isNot(tok::r_paren))
 561         return TPResult::False();
 562       ConsumeParen();
 563     }
 564   } else if (!mayBeAbstract) {
 565     return TPResult::False();
 566   }
 567
 568   while (1) {
 569     TPResult TPR(TPResult::Ambiguous());
 570
 571     // abstract-declarator: ...
 572     if (Tok.is(tok::ellipsis))
 573       ConsumeToken();
 574
 575     if (Tok.is(tok::l_paren)) {
 576       // Check whether we have a function declarator or a possible ctor-style
 577       // initializer that follows the declarator. Note that ctor-style
 578       // initializers are not possible in contexts where abstract declarators
 579       // are allowed.
 580       if (!mayBeAbstract && !isCXXFunctionDeclarator(false/*warnIfAmbiguous*/))
 581         break;
 582
 583       // direct-declarator '(' parameter-declaration-clause ')'
 584       //        cv-qualifier-seq[opt] exception-specification[opt]
 585       ConsumeParen();
 586       TPR = TryParseFunctionDeclarator();
 587     } else if (Tok.is(tok::l_square)) {
 588       // direct-declarator '[' constant-expression[opt] ']'
 589       // direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
 590       TPR = TryParseBracketDeclarator();
 591     } else {
 592       break;
 593     }
 594
 595     if (TPR != TPResult::Ambiguous())
 596       return TPR;
 597   }
 598
 599   return TPResult::Ambiguous();
 600 }
 601
 602 Parser::TPResult
 603 Parser::isExpressionOrTypeSpecifierSimple(tok::TokenKind Kind) {
 604   switch (Kind) {
 605   // Obviously starts an expression.
 606   case tok::numeric_constant:
 607   case tok::char_constant:
 608   case tok::string_literal:
 609   case tok::wide_string_literal:
 610   case tok::l_square:
 611   case tok::l_paren:
 612   case tok::amp:
 613   case tok::ampamp:
 614   case tok::star:
 615   case tok::plus:
 616   case tok::plusplus:
 617   case tok::minus:
 618   case tok::minusminus:
 619   case tok::tilde:
 620   case tok::exclaim:
 621   case tok::kw_sizeof:
 622   case tok::kw___func__:
 623   case tok::kw_const_cast:
 624   case tok::kw_delete:
 625   case tok::kw_dynamic_cast:
 626   case tok::kw_false:
 627   case tok::kw_new:
 628   case tok::kw_operator:
 629   case tok::kw_reinterpret_cast:
 630   case tok::kw_static_cast:
 631   case tok::kw_this:
 632   case tok::kw_throw:
 633   case tok::kw_true:
 634   case tok::kw_typeid:
 635   case tok::kw_alignof:
 636   case tok::kw_noexcept:
 637   case tok::kw_nullptr:
 638   case tok::kw___null:
 639   case tok::kw___alignof:
 640   case tok::kw___builtin_choose_expr:
 641   case tok::kw___builtin_offsetof:
 642   case tok::kw___builtin_types_compatible_p:
 643   case tok::kw___builtin_va_arg:
 644   case tok::kw___imag:
 645   case tok::kw___real:
 646   case tok::kw___FUNCTION__:
 647   case tok::kw___PRETTY_FUNCTION__:
 648   case tok::kw___has_nothrow_assign:
 649   case tok::kw___has_nothrow_copy:
 650   case tok::kw___has_nothrow_constructor:
 651   case tok::kw___has_trivial_assign:
 652   case tok::kw___has_trivial_copy:
 653   case tok::kw___has_trivial_constructor:
 654   case tok::kw___has_trivial_destructor:
 655   case tok::kw___has_virtual_destructor:
 656   case tok::kw___is_abstract:
 657   case tok::kw___is_base_of:
 658   case tok::kw___is_class:
 659   case tok::kw___is_convertible_to:
 660   case tok::kw___is_empty:
 661   case tok::kw___is_enum:
 662   case tok::kw___is_literal:
 663   case tok::kw___is_literal_type:
 664   case tok::kw___is_pod:
 665   case tok::kw___is_polymorphic:
 666   case tok::kw___is_trivial:
 667   case tok::kw___is_trivially_copyable:
 668   case tok::kw___is_union:
 669   case tok::kw___uuidof:
 670     return TPResult::True();
 671
 672   // Obviously starts a type-specifier-seq:
 673   case tok::kw_char:
 674   case tok::kw_const:
 675   case tok::kw_double:
 676   case tok::kw_enum:
 677   case tok::kw_float:
 678   case tok::kw_int:
 679   case tok::kw_long:
 680   case tok::kw___int64:
 681   case tok::kw_restrict:
 682   case tok::kw_short:
 683   case tok::kw_signed:
 684   case tok::kw_struct:
 685   case tok::kw_union:
 686   case tok::kw_unsigned:
 687   case tok::kw_void:
 688   case tok::kw_volatile:
 689   case tok::kw__Bool:
 690   case tok::kw__Complex:
 691   case tok::kw_class:
 692   case tok::kw_typename:
 693   case tok::kw_wchar_t:
 694   case tok::kw_char16_t:
 695   case tok::kw_char32_t:
 696   case tok::kw_decltype:
 697   case tok::kw___underlying_type:
 698   case tok::kw_thread_local:
 699   case tok::kw__Decimal32:
 700   case tok::kw__Decimal64:
 701   case tok::kw__Decimal128:
 702   case tok::kw___thread:
 703   case tok::kw_typeof:
 704   case tok::kw___cdecl:
 705   case tok::kw___stdcall:
 706   case tok::kw___fastcall:
 707   case tok::kw___thiscall:
 708   case tok::kw___vector:
 709   case tok::kw___pixel:
 710     return TPResult::False();
 711
 712   default:
 713     break;
 714   }
 715
 716   return TPResult::Ambiguous();
 717 }
 718
 719 /// isCXXDeclarationSpecifier - Returns TPResult::True() if it is a declaration
 720 /// specifier, TPResult::False() if it is not, TPResult::Ambiguous() if it could
 721 /// be either a decl-specifier or a function-style cast, and TPResult::Error()
 722 /// if a parsing error was found and reported.
 723 ///
 724 ///         decl-specifier:
 725 ///           storage-class-specifier
 726 ///           type-specifier
 727 ///           function-specifier
 728 ///           'friend'
 729 ///           'typedef'
 730 /// [C++0x]   'constexpr'
 731 /// [GNU]     attributes declaration-specifiers[opt]
 732 ///
 733 ///         storage-class-specifier:
 734 ///           'register'
 735 ///           'static'
 736 ///           'extern'
 737 ///           'mutable'
 738 ///           'auto'
 739 /// [GNU]     '__thread'
 740 ///
 741 ///         function-specifier:
 742 ///           'inline'
 743 ///           'virtual'
 744 ///           'explicit'
 745 ///
 746 ///         typedef-name:
 747 ///           identifier
 748 ///
 749 ///         type-specifier:
 750 ///           simple-type-specifier
 751 ///           class-specifier
 752 ///           enum-specifier
 753 ///           elaborated-type-specifier
 754 ///           typename-specifier
 755 ///           cv-qualifier
 756 ///
 757 ///         simple-type-specifier:
 758 ///           '::'[opt] nested-name-specifier[opt] type-name
 759 ///           '::'[opt] nested-name-specifier 'template'
 760 ///                 simple-template-id                              [TODO]
 761 ///           'char'
 762 ///           'wchar_t'
 763 ///           'bool'
 764 ///           'short'
 765 ///           'int'
 766 ///           'long'
 767 ///           'signed'
 768 ///           'unsigned'
 769 ///           'float'
 770 ///           'double'
 771 ///           'void'
 772 /// [GNU]     typeof-specifier
 773 /// [GNU]     '_Complex'
 774 /// [C++0x]   'auto'                                                [TODO]
 775 /// [C++0x]   'decltype' ( expression )
 776 ///
 777 ///         type-name:
 778 ///           class-name
 779 ///           enum-name
 780 ///           typedef-name
 781 ///
 782 ///         elaborated-type-specifier:
 783 ///           class-key '::'[opt] nested-name-specifier[opt] identifier
 784 ///           class-key '::'[opt] nested-name-specifier[opt] 'template'[opt]
 785 ///               simple-template-id
 786 ///           'enum' '::'[opt] nested-name-specifier[opt] identifier
 787 ///
 788 ///         enum-name:
 789 ///           identifier
 790 ///
 791 ///         enum-specifier:
 792 ///           'enum' identifier[opt] '{' enumerator-list[opt] '}'
 793 ///           'enum' identifier[opt] '{' enumerator-list ',' '}'
 794 ///
 795 ///         class-specifier:
 796 ///           class-head '{' member-specification[opt] '}'
 797 ///
 798 ///         class-head:
 799 ///           class-key identifier[opt] base-clause[opt]
 800 ///           class-key nested-name-specifier identifier base-clause[opt]
 801 ///           class-key nested-name-specifier[opt] simple-template-id
 802 ///               base-clause[opt]
 803 ///
 804 ///         class-key:
 805 ///           'class'
 806 ///           'struct'
 807 ///           'union'
 808 ///
 809 ///         cv-qualifier:
 810 ///           'const'
 811 ///           'volatile'
 812 /// [GNU]     restrict
 813 ///
 814 Parser::TPResult Parser::isCXXDeclarationSpecifier() {
 815   switch (Tok.getKind()) {
 816   case tok::identifier:   // foo::bar
 817     // Check for need to substitute AltiVec __vector keyword
 818     // for "vector" identifier.
 819     if (TryAltiVecVectorToken())
 820       return TPResult::True();
 821     // Fall through.
 822   case tok::kw_typename:  // typename T::type
 823     // Annotate typenames and C++ scope specifiers.  If we get one, just
 824     // recurse to handle whatever we get.
 825     if (TryAnnotateTypeOrScopeToken())
 826       return TPResult::Error();
 827     if (Tok.is(tok::identifier))
 828       return TPResult::False();
 829     return isCXXDeclarationSpecifier();
 830
 831   case tok::coloncolon: {    // ::foo::bar
 832     const Token &Next = NextToken();
 833     if (Next.is(tok::kw_new) ||    // ::new
 834         Next.is(tok::kw_delete))   // ::delete
 835       return TPResult::False();
 836
 837     // Annotate typenames and C++ scope specifiers.  If we get one, just
 838     // recurse to handle whatever we get.
 839     if (TryAnnotateTypeOrScopeToken())
 840       return TPResult::Error();
 841     return isCXXDeclarationSpecifier();
 842   }
 843
 844     // decl-specifier:
 845     //   storage-class-specifier
 846     //   type-specifier
 847     //   function-specifier
 848     //   'friend'
 849     //   'typedef'
 850     //   'constexpr'
 851   case tok::kw_friend:
 852   case tok::kw_typedef:
 853   case tok::kw_constexpr:
 854     // storage-class-specifier
 855   case tok::kw_register:
 856   case tok::kw_static:
 857   case tok::kw_extern:
 858   case tok::kw_mutable:
 859   case tok::kw_auto:
 860   case tok::kw___thread:
 861     // function-specifier
 862   case tok::kw_inline:
 863   case tok::kw_virtual:
 864   case tok::kw_explicit:
 865
 866     // type-specifier:
 867     //   simple-type-specifier
 868     //   class-specifier
 869     //   enum-specifier
 870     //   elaborated-type-specifier
 871     //   typename-specifier
 872     //   cv-qualifier
 873
 874     // class-specifier
 875     // elaborated-type-specifier
 876   case tok::kw_class:
 877   case tok::kw_struct:
 878   case tok::kw_union:
 879     // enum-specifier
 880   case tok::kw_enum:
 881     // cv-qualifier
 882   case tok::kw_const:
 883   case tok::kw_volatile:
 884
 885     // GNU
 886   case tok::kw_restrict:
 887   case tok::kw__Complex:
 888   case tok::kw___attribute:
 889     return TPResult::True();
 890
 891     // Microsoft
 892   case tok::kw___declspec:
 893   case tok::kw___cdecl:
 894   case tok::kw___stdcall:
 895   case tok::kw___fastcall:
 896   case tok::kw___thiscall:
 897   case tok::kw___w64:
 898   case tok::kw___ptr64:
 899   case tok::kw___forceinline:
 900     return TPResult::True();
 901
 902     // Borland
 903   case tok::kw___pascal:
 904     return TPResult::True();
 905
 906     // AltiVec
 907   case tok::kw___vector:
 908     return TPResult::True();
 909
 910   case tok::annot_template_id: {
 911     TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
 912     if (TemplateId->Kind != TNK_Type_template)
 913       return TPResult::False();
 914     CXXScopeSpec SS;
 915     AnnotateTemplateIdTokenAsType();
 916     assert(Tok.is(tok::annot_typename));
 917     goto case_typename;
 918   }
 919
 920   case tok::annot_cxxscope: // foo::bar or ::foo::bar, but already parsed
 921     // We've already annotated a scope; try to annotate a type.
 922     if (TryAnnotateTypeOrScopeToken())
 923       return TPResult::Error();
 924     if (!Tok.is(tok::annot_typename))
 925       return TPResult::False();
 926     // If that succeeded, fallthrough into the generic simple-type-id case.
 927
 928     // The ambiguity resides in a simple-type-specifier/typename-specifier
 929     // followed by a '('. The '(' could either be the start of:
 930     //
 931     //   direct-declarator:
 932     //     '(' declarator ')'
 933     //
 934     //   direct-abstract-declarator:
 935     //     '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
 936     //              exception-specification[opt]
 937     //     '(' abstract-declarator ')'
 938     //
 939     // or part of a function-style cast expression:
 940     //
 941     //     simple-type-specifier '(' expression-list[opt] ')'
 942     //
 943
 944     // simple-type-specifier:
 945
 946   case tok::annot_typename:
 947   case_typename:
 948     // In Objective-C, we might have a protocol-qualified type.
 949     if (getLang().ObjC1 && NextToken().is(tok::less)) {
 950       // Tentatively parse the
 951       TentativeParsingAction PA(*this);
 952       ConsumeToken(); // The type token
 953
 954       TPResult TPR = TryParseProtocolQualifiers();
 955       bool isFollowedByParen = Tok.is(tok::l_paren);
 956
 957       PA.Revert();
 958
 959       if (TPR == TPResult::Error())
 960         return TPResult::Error();
 961
 962       if (isFollowedByParen)
 963         return TPResult::Ambiguous();
 964
 965       return TPResult::True();
 966     }
 967
 968   case tok::kw_char:
 969   case tok::kw_wchar_t:
 970   case tok::kw_char16_t:
 971   case tok::kw_char32_t:
 972   case tok::kw_bool:
 973   case tok::kw_short:
 974   case tok::kw_int:
 975   case tok::kw_long:
 976   case tok::kw___int64:
 977   case tok::kw_signed:
 978   case tok::kw_unsigned:
 979   case tok::kw_float:
 980   case tok::kw_double:
 981   case tok::kw_void:
 982     if (NextToken().is(tok::l_paren))
 983       return TPResult::Ambiguous();
 984
 985     if (isStartOfObjCClassMessageMissingOpenBracket())
 986       return TPResult::False();
 987
 988     return TPResult::True();
 989
 990   // GNU typeof support.
 991   case tok::kw_typeof: {
 992     if (NextToken().isNot(tok::l_paren))
 993       return TPResult::True();
 994
 995     TentativeParsingAction PA(*this);
 996
 997     TPResult TPR = TryParseTypeofSpecifier();
 998     bool isFollowedByParen = Tok.is(tok::l_paren);
 999
1000     PA.Revert();
1001
1002     if (TPR == TPResult::Error())
1003       return TPResult::Error();
1004
1005     if (isFollowedByParen)
1006       return TPResult::Ambiguous();
1007
1008     return TPResult::True();
1009   }
1010
1011   // C++0x decltype support.
1012   case tok::kw_decltype:
1013     return TPResult::True();
1014
1015   // C++0x type traits support
1016   case tok::kw___underlying_type:
1017     return TPResult::True();
1018
1019   default:
1020     return TPResult::False();
1021   }
1022 }
1023
1024 /// [GNU] typeof-specifier:
1025 ///         'typeof' '(' expressions ')'
1026 ///         'typeof' '(' type-name ')'
1027 ///
1028 Parser::TPResult Parser::TryParseTypeofSpecifier() {
1029   assert(Tok.is(tok::kw_typeof) && "Expected 'typeof'!");
1030   ConsumeToken();
1031
1032   assert(Tok.is(tok::l_paren) && "Expected '('");
1033   // Parse through the parens after 'typeof'.
1034   ConsumeParen();
1035   if (!SkipUntil(tok::r_paren))
1036     return TPResult::Error();
1037
1038   return TPResult::Ambiguous();
1039 }
1040
1041 /// [ObjC] protocol-qualifiers:
1042 ////         '<' identifier-list '>'
1043 Parser::TPResult Parser::TryParseProtocolQualifiers() {
1044   assert(Tok.is(tok::less) && "Expected '<' for qualifier list");
1045   ConsumeToken();
1046   do {
1047     if (Tok.isNot(tok::identifier))
1048       return TPResult::Error();
1049     ConsumeToken();
1050
1051     if (Tok.is(tok::comma)) {
1052       ConsumeToken();
1053       continue;
1054     }
1055
1056     if (Tok.is(tok::greater)) {
1057       ConsumeToken();
1058       return TPResult::Ambiguous();
1059     }
1060   } while (false);
1061
1062   return TPResult::Error();
1063 }
1064
1065 Parser::TPResult Parser::TryParseDeclarationSpecifier() {
1066   TPResult TPR = isCXXDeclarationSpecifier();
1067   if (TPR != TPResult::Ambiguous())
1068     return TPR;
1069
1070   if (Tok.is(tok::kw_typeof))
1071     TryParseTypeofSpecifier();
1072   else {
1073     ConsumeToken();
1074
1075     if (getLang().ObjC1 && Tok.is(tok::less))
1076       TryParseProtocolQualifiers();
1077   }
1078
1079   assert(Tok.is(tok::l_paren) && "Expected '('!");
1080   return TPResult::Ambiguous();
1081 }
1082
1083 /// isCXXFunctionDeclarator - Disambiguates between a function declarator or
1084 /// a constructor-style initializer, when parsing declaration statements.
1085 /// Returns true for function declarator and false for constructor-style
1086 /// initializer.
1087 /// If during the disambiguation process a parsing error is encountered,
1088 /// the function returns true to let the declaration parsing code handle it.
1089 ///
1090 /// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1091 ///         exception-specification[opt]
1092 ///
1093 bool Parser::isCXXFunctionDeclarator(bool warnIfAmbiguous) {
1094
1095   // C++ 8.2p1:
1096   // The ambiguity arising from the similarity between a function-style cast and
1097   // a declaration mentioned in 6.8 can also occur in the context of a
1098   // declaration. In that context, the choice is between a function declaration
1099   // with a redundant set of parentheses around a parameter name and an object
1100   // declaration with a function-style cast as the initializer. Just as for the
1101   // ambiguities mentioned in 6.8, the resolution is to consider any construct
1102   // that could possibly be a declaration a declaration.
1103
1104   TentativeParsingAction PA(*this);
1105
1106   ConsumeParen();
1107   TPResult TPR = TryParseParameterDeclarationClause();
1108   if (TPR == TPResult::Ambiguous() && Tok.isNot(tok::r_paren))
1109     TPR = TPResult::False();
1110
1111   SourceLocation TPLoc = Tok.getLocation();
1112   PA.Revert();
1113
1114   // In case of an error, let the declaration parsing code handle it.
1115   if (TPR == TPResult::Error())
1116     return true;
1117
1118   if (TPR == TPResult::Ambiguous()) {
1119     // Function declarator has precedence over constructor-style initializer.
1120     // Emit a warning just in case the author intended a variable definition.
1121     if (warnIfAmbiguous)
1122       Diag(Tok, diag::warn_parens_disambiguated_as_function_decl)
1123         << SourceRange(Tok.getLocation(), TPLoc);
1124     return true;
1125   }
1126
1127   return TPR == TPResult::True();
1128 }
1129
1130 /// parameter-declaration-clause:
1131 ///   parameter-declaration-list[opt] '...'[opt]
1132 ///   parameter-declaration-list ',' '...'
1133 ///
1134 /// parameter-declaration-list:
1135 ///   parameter-declaration
1136 ///   parameter-declaration-list ',' parameter-declaration
1137 ///
1138 /// parameter-declaration:
1139 ///   decl-specifier-seq declarator attributes[opt]
1140 ///   decl-specifier-seq declarator attributes[opt] '=' assignment-expression
1141 ///   decl-specifier-seq abstract-declarator[opt] attributes[opt]
1142 ///   decl-specifier-seq abstract-declarator[opt] attributes[opt]
1143 ///     '=' assignment-expression
1144 ///
1145 Parser::TPResult Parser::TryParseParameterDeclarationClause() {
1146
1147   if (Tok.is(tok::r_paren))
1148     return TPResult::True();
1149
1150   //   parameter-declaration-list[opt] '...'[opt]
1151   //   parameter-declaration-list ',' '...'
1152   //
1153   // parameter-declaration-list:
1154   //   parameter-declaration
1155   //   parameter-declaration-list ',' parameter-declaration
1156   //
1157   while (1) {
1158     // '...'[opt]
1159     if (Tok.is(tok::ellipsis)) {
1160       ConsumeToken();
1161       return TPResult::True(); // '...' is a sign of a function declarator.
1162     }
1163
1164     ParsedAttributes attrs(AttrFactory);
1165     MaybeParseMicrosoftAttributes(attrs);
1166
1167     // decl-specifier-seq
1168     TPResult TPR = TryParseDeclarationSpecifier();
1169     if (TPR != TPResult::Ambiguous())
1170       return TPR;
1171
1172     // declarator
1173     // abstract-declarator[opt]
1174     TPR = TryParseDeclarator(true/*mayBeAbstract*/);
1175     if (TPR != TPResult::Ambiguous())
1176       return TPR;
1177
1178     // [GNU] attributes[opt]
1179     if (Tok.is(tok::kw___attribute))
1180       return TPResult::True();
1181
1182     if (Tok.is(tok::equal)) {
1183       // '=' assignment-expression
1184       // Parse through assignment-expression.
1185       tok::TokenKind StopToks[2] ={ tok::comma, tok::r_paren };
1186       if (!SkipUntil(StopToks, 2, true/*StopAtSemi*/, true/*DontConsume*/))
1187         return TPResult::Error();
1188     }
1189
1190     if (Tok.is(tok::ellipsis)) {
1191       ConsumeToken();
1192       return TPResult::True(); // '...' is a sign of a function declarator.
1193     }
1194
1195     if (Tok.isNot(tok::comma))
1196       break;
1197     ConsumeToken(); // the comma.
1198   }
1199
1200   return TPResult::Ambiguous();
1201 }
1202
1203 /// TryParseFunctionDeclarator - We parsed a '(' and we want to try to continue
1204 /// parsing as a function declarator.
1205 /// If TryParseFunctionDeclarator fully parsed the function declarator, it will
1206 /// return TPResult::Ambiguous(), otherwise it will return either False() or
1207 /// Error().
1208 ///
1209 /// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1210 ///         exception-specification[opt]
1211 ///
1212 /// exception-specification:
1213 ///   'throw' '(' type-id-list[opt] ')'
1214 ///
1215 Parser::TPResult Parser::TryParseFunctionDeclarator() {
1216
1217   // The '(' is already parsed.
1218
1219   TPResult TPR = TryParseParameterDeclarationClause();
1220   if (TPR == TPResult::Ambiguous() && Tok.isNot(tok::r_paren))
1221     TPR = TPResult::False();
1222
1223   if (TPR == TPResult::False() || TPR == TPResult::Error())
1224     return TPR;
1225
1226   // Parse through the parens.
1227   if (!SkipUntil(tok::r_paren))
1228     return TPResult::Error();
1229
1230   // cv-qualifier-seq
1231   while (Tok.is(tok::kw_const)    ||
1232          Tok.is(tok::kw_volatile) ||
1233          Tok.is(tok::kw_restrict)   )
1234     ConsumeToken();
1235
1236   // ref-qualifier[opt]
1237   if (Tok.is(tok::amp) || Tok.is(tok::ampamp))
1238     ConsumeToken();
1239
1240   // exception-specification
1241   if (Tok.is(tok::kw_throw)) {
1242     ConsumeToken();
1243     if (Tok.isNot(tok::l_paren))
1244       return TPResult::Error();
1245
1246     // Parse through the parens after 'throw'.
1247     ConsumeParen();
1248     if (!SkipUntil(tok::r_paren))
1249       return TPResult::Error();
1250   }
1251   if (Tok.is(tok::kw_noexcept)) {
1252     ConsumeToken();
1253     // Possibly an expression as well.
1254     if (Tok.is(tok::l_paren)) {
1255       // Find the matching rparen.
1256       ConsumeParen();
1257       if (!SkipUntil(tok::r_paren))
1258         return TPResult::Error();
1259     }
1260   }
1261
1262   return TPResult::Ambiguous();
1263 }
1264
1265 /// '[' constant-expression[opt] ']'
1266 ///
1267 Parser::TPResult Parser::TryParseBracketDeclarator() {
1268   ConsumeBracket();
1269   if (!SkipUntil(tok::r_square))
1270     return TPResult::Error();
1271
1272   return TPResult::Ambiguous();
1273 }