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(/*AllowForRangeDecl=*/false);
  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 /// (if AllowForRangeDecl specified)
  79 /// for ( for-range-declaration : for-range-initializer ) statement
  80 /// for-range-declaration:
  81 ///    attribute-specifier-seqopt type-specifier-seq declarator
  82 bool Parser::isCXXSimpleDeclaration(bool AllowForRangeDecl) {
  83   // C++ 6.8p1:
  84   // There is an ambiguity in the grammar involving expression-statements and
  85   // declarations: An expression-statement with a function-style explicit type
  86   // conversion (5.2.3) as its leftmost subexpression can be indistinguishable
  87   // from a declaration where the first declarator starts with a '('. In those
  88   // cases the statement is a declaration. [Note: To disambiguate, the whole
  89   // statement might have to be examined to determine if it is an
  90   // expression-statement or a declaration].
  91
  92   // C++ 6.8p3:
  93   // The disambiguation is purely syntactic; that is, the meaning of the names
  94   // occurring in such a statement, beyond whether they are type-names or not,
  95   // is not generally used in or changed by the disambiguation. Class
  96   // templates are instantiated as necessary to determine if a qualified name
  97   // is a type-name. Disambiguation precedes parsing, and a statement
  98   // disambiguated as a declaration may be an ill-formed declaration.
  99
 100   // We don't have to parse all of the decl-specifier-seq part. There's only
 101   // an ambiguity if the first decl-specifier is
 102   // simple-type-specifier/typename-specifier followed by a '(', which may
 103   // indicate a function-style cast expression.
 104   // isCXXDeclarationSpecifier will return TPResult::Ambiguous only in such
 105   // a case.
 106
 107   bool InvalidAsDeclaration = false;
 108   TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
 109                                            &InvalidAsDeclaration);
 110   if (TPR != TPResult::Ambiguous)
 111     return TPR != TPResult::False; // Returns true for TPResult::True or
 112                                    // TPResult::Error.
 113
 114   // FIXME: TryParseSimpleDeclaration doesn't look past the first initializer,
 115   // and so gets some cases wrong. We can't carry on if we've already seen
 116   // something which makes this statement invalid as a declaration in this case,
 117   // since it can cause us to misparse valid code. Revisit this once
 118   // TryParseInitDeclaratorList is fixed.
 119   if (InvalidAsDeclaration)
 120     return false;
 121
 122   // FIXME: Add statistics about the number of ambiguous statements encountered
 123   // and how they were resolved (number of declarations+number of expressions).
 124
 125   // Ok, we have a simple-type-specifier/typename-specifier followed by a '(',
 126   // or an identifier which doesn't resolve as anything. We need tentative
 127   // parsing...
 128
 129   TentativeParsingAction PA(*this);
 130   TPR = TryParseSimpleDeclaration(AllowForRangeDecl);
 131   PA.Revert();
 132
 133   // In case of an error, let the declaration parsing code handle it.
 134   if (TPR == TPResult::Error)
 135     return true;
 136
 137   // Declarations take precedence over expressions.
 138   if (TPR == TPResult::Ambiguous)
 139     TPR = TPResult::True;
 140
 141   assert(TPR == TPResult::True || TPR == TPResult::False);
 142   return TPR == TPResult::True;
 143 }
 144
 145 /// Try to consume a token sequence that we've already identified as
 146 /// (potentially) starting a decl-specifier.
 147 Parser::TPResult Parser::TryConsumeDeclarationSpecifier() {
 148   switch (Tok.getKind()) {
 149   case tok::kw__Atomic:
 150     if (NextToken().isNot(tok::l_paren)) {
 151       ConsumeToken();
 152       break;
 153     }
 154     // Fall through.
 155   case tok::kw_typeof:
 156   case tok::kw___attribute:
 157   case tok::kw___underlying_type: {
 158     ConsumeToken();
 159     if (Tok.isNot(tok::l_paren))
 160       return TPResult::Error;
 161     ConsumeParen();
 162     if (!SkipUntil(tok::r_paren))
 163       return TPResult::Error;
 164     break;
 165   }
 166
 167   case tok::kw_class:
 168   case tok::kw_struct:
 169   case tok::kw_union:
 170   case tok::kw___interface:
 171   case tok::kw_enum:
 172     // elaborated-type-specifier:
 173     //     class-key attribute-specifier-seq[opt]
 174     //         nested-name-specifier[opt] identifier
 175     //     class-key nested-name-specifier[opt] template[opt] simple-template-id
 176     //     enum nested-name-specifier[opt] identifier
 177     //
 178     // FIXME: We don't support class-specifiers nor enum-specifiers here.
 179     ConsumeToken();
 180
 181     // Skip attributes.
 182     while (Tok.is(tok::l_square) || Tok.is(tok::kw___attribute) ||
 183            Tok.is(tok::kw___declspec) || Tok.is(tok::kw_alignas)) {
 184       if (Tok.is(tok::l_square)) {
 185         ConsumeBracket();
 186         if (!SkipUntil(tok::r_square))
 187           return TPResult::Error;
 188       } else {
 189         ConsumeToken();
 190         if (Tok.isNot(tok::l_paren))
 191           return TPResult::Error;
 192         ConsumeParen();
 193         if (!SkipUntil(tok::r_paren))
 194           return TPResult::Error;
 195       }
 196     }
 197
 198     if (TryAnnotateCXXScopeToken())
 199       return TPResult::Error;
 200     if (Tok.is(tok::annot_cxxscope))
 201       ConsumeToken();
 202     if (Tok.isNot(tok::identifier) && Tok.isNot(tok::annot_template_id))
 203       return TPResult::Error;
 204     ConsumeToken();
 205     break;
 206
 207   case tok::annot_cxxscope:
 208     ConsumeToken();
 209     // Fall through.
 210   default:
 211     ConsumeToken();
 212
 213     if (getLangOpts().ObjC1 && Tok.is(tok::less))
 214       return TryParseProtocolQualifiers();
 215     break;
 216   }
 217
 218   return TPResult::Ambiguous;
 219 }
 220
 221 /// simple-declaration:
 222 ///   decl-specifier-seq init-declarator-list[opt] ';'
 223 ///
 224 /// (if AllowForRangeDecl specified)
 225 /// for ( for-range-declaration : for-range-initializer ) statement
 226 /// for-range-declaration:
 227 ///    attribute-specifier-seqopt type-specifier-seq declarator
 228 ///
 229 Parser::TPResult Parser::TryParseSimpleDeclaration(bool AllowForRangeDecl) {
 230   if (TryConsumeDeclarationSpecifier() == TPResult::Error)
 231     return TPResult::Error;
 232
 233   // Two decl-specifiers in a row conclusively disambiguate this as being a
 234   // simple-declaration. Don't bother calling isCXXDeclarationSpecifier in the
 235   // overwhelmingly common case that the next token is a '('.
 236   if (Tok.isNot(tok::l_paren)) {
 237     TPResult TPR = isCXXDeclarationSpecifier();
 238     if (TPR == TPResult::Ambiguous)
 239       return TPResult::True;
 240     if (TPR == TPResult::True || TPR == TPResult::Error)
 241       return TPR;
 242     assert(TPR == TPResult::False);
 243   }
 244
 245   TPResult TPR = TryParseInitDeclaratorList();
 246   if (TPR != TPResult::Ambiguous)
 247     return TPR;
 248
 249   if (Tok.isNot(tok::semi) && (!AllowForRangeDecl || Tok.isNot(tok::colon)))
 250     return TPResult::False;
 251
 252   return TPResult::Ambiguous;
 253 }
 254
 255 /// Tentatively parse an init-declarator-list in order to disambiguate it from
 256 /// an expression.
 257 ///
 258 ///       init-declarator-list:
 259 ///         init-declarator
 260 ///         init-declarator-list ',' init-declarator
 261 ///
 262 ///       init-declarator:
 263 ///         declarator initializer[opt]
 264 /// [GNU]   declarator simple-asm-expr[opt] attributes[opt] initializer[opt]
 265 ///
 266 ///       initializer:
 267 ///         brace-or-equal-initializer
 268 ///         '(' expression-list ')'
 269 ///
 270 ///       brace-or-equal-initializer:
 271 ///         '=' initializer-clause
 272 /// [C++11] braced-init-list
 273 ///
 274 ///       initializer-clause:
 275 ///         assignment-expression
 276 ///         braced-init-list
 277 ///
 278 ///       braced-init-list:
 279 ///         '{' initializer-list ','[opt] '}'
 280 ///         '{' '}'
 281 ///
 282 Parser::TPResult Parser::TryParseInitDeclaratorList() {
 283   while (1) {
 284     // declarator
 285     TPResult TPR = TryParseDeclarator(false/*mayBeAbstract*/);
 286     if (TPR != TPResult::Ambiguous)
 287       return TPR;
 288
 289     // [GNU] simple-asm-expr[opt] attributes[opt]
 290     if (Tok.is(tok::kw_asm) || Tok.is(tok::kw___attribute))
 291       return TPResult::True;
 292
 293     // initializer[opt]
 294     if (Tok.is(tok::l_paren)) {
 295       // Parse through the parens.
 296       ConsumeParen();
 297       if (!SkipUntil(tok::r_paren, StopAtSemi))
 298         return TPResult::Error;
 299     } else if (Tok.is(tok::l_brace)) {
 300       // A left-brace here is sufficient to disambiguate the parse; an
 301       // expression can never be followed directly by a braced-init-list.
 302       return TPResult::True;
 303     } else if (Tok.is(tok::equal) || isTokIdentifier_in()) {
 304       // MSVC and g++ won't examine the rest of declarators if '=' is
 305       // encountered; they just conclude that we have a declaration.
 306       // EDG parses the initializer completely, which is the proper behavior
 307       // for this case.
 308       //
 309       // At present, Clang follows MSVC and g++, since the parser does not have
 310       // the ability to parse an expression fully without recording the
 311       // results of that parse.
 312       // FIXME: Handle this case correctly.
 313       //
 314       // Also allow 'in' after an Objective-C declaration as in:
 315       // for (int (^b)(void) in array). Ideally this should be done in the
 316       // context of parsing for-init-statement of a foreach statement only. But,
 317       // in any other context 'in' is invalid after a declaration and parser
 318       // issues the error regardless of outcome of this decision.
 319       // FIXME: Change if above assumption does not hold.
 320       return TPResult::True;
 321     }
 322
 323     if (!TryConsumeToken(tok::comma))
 324       break;
 325   }
 326
 327   return TPResult::Ambiguous;
 328 }
 329
 330 /// isCXXConditionDeclaration - Disambiguates between a declaration or an
 331 /// expression for a condition of a if/switch/while/for statement.
 332 /// If during the disambiguation process a parsing error is encountered,
 333 /// the function returns true to let the declaration parsing code handle it.
 334 ///
 335 ///       condition:
 336 ///         expression
 337 ///         type-specifier-seq declarator '=' assignment-expression
 338 /// [C++11] type-specifier-seq declarator '=' initializer-clause
 339 /// [C++11] type-specifier-seq declarator braced-init-list
 340 /// [GNU]   type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
 341 ///             '=' assignment-expression
 342 ///
 343 bool Parser::isCXXConditionDeclaration() {
 344   TPResult TPR = isCXXDeclarationSpecifier();
 345   if (TPR != TPResult::Ambiguous)
 346     return TPR != TPResult::False; // Returns true for TPResult::True or
 347                                    // TPResult::Error.
 348
 349   // FIXME: Add statistics about the number of ambiguous statements encountered
 350   // and how they were resolved (number of declarations+number of expressions).
 351
 352   // Ok, we have a simple-type-specifier/typename-specifier followed by a '('.
 353   // We need tentative parsing...
 354
 355   TentativeParsingAction PA(*this);
 356
 357   // type-specifier-seq
 358   TryConsumeDeclarationSpecifier();
 359   assert(Tok.is(tok::l_paren) && "Expected '('");
 360
 361   // declarator
 362   TPR = TryParseDeclarator(false/*mayBeAbstract*/);
 363
 364   // In case of an error, let the declaration parsing code handle it.
 365   if (TPR == TPResult::Error)
 366     TPR = TPResult::True;
 367
 368   if (TPR == TPResult::Ambiguous) {
 369     // '='
 370     // [GNU] simple-asm-expr[opt] attributes[opt]
 371     if (Tok.is(tok::equal)  ||
 372         Tok.is(tok::kw_asm) || Tok.is(tok::kw___attribute))
 373       TPR = TPResult::True;
 374     else if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))
 375       TPR = TPResult::True;
 376     else
 377       TPR = TPResult::False;
 378   }
 379
 380   PA.Revert();
 381
 382   assert(TPR == TPResult::True || TPR == TPResult::False);
 383   return TPR == TPResult::True;
 384 }
 385
 386   /// \brief Determine whether the next set of tokens contains a type-id.
 387   ///
 388   /// The context parameter states what context we're parsing right
 389   /// now, which affects how this routine copes with the token
 390   /// following the type-id. If the context is TypeIdInParens, we have
 391   /// already parsed the '(' and we will cease lookahead when we hit
 392   /// the corresponding ')'. If the context is
 393   /// TypeIdAsTemplateArgument, we've already parsed the '<' or ','
 394   /// before this template argument, and will cease lookahead when we
 395   /// hit a '>', '>>' (in C++0x), or ','. Returns true for a type-id
 396   /// and false for an expression.  If during the disambiguation
 397   /// process a parsing error is encountered, the function returns
 398   /// true to let the declaration parsing code handle it.
 399   ///
 400   /// type-id:
 401   ///   type-specifier-seq abstract-declarator[opt]
 402   ///
 403 bool Parser::isCXXTypeId(TentativeCXXTypeIdContext Context, bool &isAmbiguous) {
 404
 405   isAmbiguous = false;
 406
 407   // C++ 8.2p2:
 408   // The ambiguity arising from the similarity between a function-style cast and
 409   // a type-id can occur in different contexts. The ambiguity appears as a
 410   // choice between a function-style cast expression and a declaration of a
 411   // type. The resolution is that any construct that could possibly be a type-id
 412   // in its syntactic context shall be considered a type-id.
 413
 414   TPResult TPR = isCXXDeclarationSpecifier();
 415   if (TPR != TPResult::Ambiguous)
 416     return TPR != TPResult::False; // Returns true for TPResult::True or
 417                                      // TPResult::Error.
 418
 419   // FIXME: Add statistics about the number of ambiguous statements encountered
 420   // and how they were resolved (number of declarations+number of expressions).
 421
 422   // Ok, we have a simple-type-specifier/typename-specifier followed by a '('.
 423   // We need tentative parsing...
 424
 425   TentativeParsingAction PA(*this);
 426
 427   // type-specifier-seq
 428   TryConsumeDeclarationSpecifier();
 429   assert(Tok.is(tok::l_paren) && "Expected '('");
 430
 431   // declarator
 432   TPR = TryParseDeclarator(true/*mayBeAbstract*/, false/*mayHaveIdentifier*/);
 433
 434   // In case of an error, let the declaration parsing code handle it.
 435   if (TPR == TPResult::Error)
 436     TPR = TPResult::True;
 437
 438   if (TPR == TPResult::Ambiguous) {
 439     // We are supposed to be inside parens, so if after the abstract declarator
 440     // we encounter a ')' this is a type-id, otherwise it's an expression.
 441     if (Context == TypeIdInParens && Tok.is(tok::r_paren)) {
 442       TPR = TPResult::True;
 443       isAmbiguous = true;
 444
 445     // We are supposed to be inside a template argument, so if after
 446     // the abstract declarator we encounter a '>', '>>' (in C++0x), or
 447     // ',', this is a type-id. Otherwise, it's an expression.
 448     } else if (Context == TypeIdAsTemplateArgument &&
 449                (Tok.is(tok::greater) || Tok.is(tok::comma) ||
 450                 (getLangOpts().CPlusPlus11 && Tok.is(tok::greatergreater)))) {
 451       TPR = TPResult::True;
 452       isAmbiguous = true;
 453
 454     } else
 455       TPR = TPResult::False;
 456   }
 457
 458   PA.Revert();
 459
 460   assert(TPR == TPResult::True || TPR == TPResult::False);
 461   return TPR == TPResult::True;
 462 }
 463
 464 /// \brief Returns true if this is a C++11 attribute-specifier. Per
 465 /// C++11 [dcl.attr.grammar]p6, two consecutive left square bracket tokens
 466 /// always introduce an attribute. In Objective-C++11, this rule does not
 467 /// apply if either '[' begins a message-send.
 468 ///
 469 /// If Disambiguate is true, we try harder to determine whether a '[[' starts
 470 /// an attribute-specifier, and return CAK_InvalidAttributeSpecifier if not.
 471 ///
 472 /// If OuterMightBeMessageSend is true, we assume the outer '[' is either an
 473 /// Obj-C message send or the start of an attribute. Otherwise, we assume it
 474 /// is not an Obj-C message send.
 475 ///
 476 /// C++11 [dcl.attr.grammar]:
 477 ///
 478 ///     attribute-specifier:
 479 ///         '[' '[' attribute-list ']' ']'
 480 ///         alignment-specifier
 481 ///
 482 ///     attribute-list:
 483 ///         attribute[opt]
 484 ///         attribute-list ',' attribute[opt]
 485 ///         attribute '...'
 486 ///         attribute-list ',' attribute '...'
 487 ///
 488 ///     attribute:
 489 ///         attribute-token attribute-argument-clause[opt]
 490 ///
 491 ///     attribute-token:
 492 ///         identifier
 493 ///         identifier '::' identifier
 494 ///
 495 ///     attribute-argument-clause:
 496 ///         '(' balanced-token-seq ')'
 497 Parser::CXX11AttributeKind
 498 Parser::isCXX11AttributeSpecifier(bool Disambiguate,
 499                                   bool OuterMightBeMessageSend) {
 500   if (Tok.is(tok::kw_alignas))
 501     return CAK_AttributeSpecifier;
 502
 503   if (Tok.isNot(tok::l_square) || NextToken().isNot(tok::l_square))
 504     return CAK_NotAttributeSpecifier;
 505
 506   // No tentative parsing if we don't need to look for ']]' or a lambda.
 507   if (!Disambiguate && !getLangOpts().ObjC1)
 508     return CAK_AttributeSpecifier;
 509
 510   TentativeParsingAction PA(*this);
 511
 512   // Opening brackets were checked for above.
 513   ConsumeBracket();
 514
 515   // Outside Obj-C++11, treat anything with a matching ']]' as an attribute.
 516   if (!getLangOpts().ObjC1) {
 517     ConsumeBracket();
 518
 519     bool IsAttribute = SkipUntil(tok::r_square);
 520     IsAttribute &= Tok.is(tok::r_square);
 521
 522     PA.Revert();
 523
 524     return IsAttribute ? CAK_AttributeSpecifier : CAK_InvalidAttributeSpecifier;
 525   }
 526
 527   // In Obj-C++11, we need to distinguish four situations:
 528   //  1a) int x[[attr]];                     C++11 attribute.
 529   //  1b) [[attr]];                          C++11 statement attribute.
 530   //   2) int x[[obj](){ return 1; }()];     Lambda in array size/index.
 531   //  3a) int x[[obj get]];                  Message send in array size/index.
 532   //  3b) [[Class alloc] init];              Message send in message send.
 533   //   4) [[obj]{ return self; }() doStuff]; Lambda in message send.
 534   // (1) is an attribute, (2) is ill-formed, and (3) and (4) are accepted.
 535
 536   // If we have a lambda-introducer, then this is definitely not a message send.
 537   // FIXME: If this disambiguation is too slow, fold the tentative lambda parse
 538   // into the tentative attribute parse below.
 539   LambdaIntroducer Intro;
 540   if (!TryParseLambdaIntroducer(Intro)) {
 541     // A lambda cannot end with ']]', and an attribute must.
 542     bool IsAttribute = Tok.is(tok::r_square);
 543
 544     PA.Revert();
 545
 546     if (IsAttribute)
 547       // Case 1: C++11 attribute.
 548       return CAK_AttributeSpecifier;
 549
 550     if (OuterMightBeMessageSend)
 551       // Case 4: Lambda in message send.
 552       return CAK_NotAttributeSpecifier;
 553
 554     // Case 2: Lambda in array size / index.
 555     return CAK_InvalidAttributeSpecifier;
 556   }
 557
 558   ConsumeBracket();
 559
 560   // If we don't have a lambda-introducer, then we have an attribute or a
 561   // message-send.
 562   bool IsAttribute = true;
 563   while (Tok.isNot(tok::r_square)) {
 564     if (Tok.is(tok::comma)) {
 565       // Case 1: Stray commas can only occur in attributes.
 566       PA.Revert();
 567       return CAK_AttributeSpecifier;
 568     }
 569
 570     // Parse the attribute-token, if present.
 571     // C++11 [dcl.attr.grammar]:
 572     //   If a keyword or an alternative token that satisfies the syntactic
 573     //   requirements of an identifier is contained in an attribute-token,
 574     //   it is considered an identifier.
 575     SourceLocation Loc;
 576     if (!TryParseCXX11AttributeIdentifier(Loc)) {
 577       IsAttribute = false;
 578       break;
 579     }
 580     if (Tok.is(tok::coloncolon)) {
 581       ConsumeToken();
 582       if (!TryParseCXX11AttributeIdentifier(Loc)) {
 583         IsAttribute = false;
 584         break;
 585       }
 586     }
 587
 588     // Parse the attribute-argument-clause, if present.
 589     if (Tok.is(tok::l_paren)) {
 590       ConsumeParen();
 591       if (!SkipUntil(tok::r_paren)) {
 592         IsAttribute = false;
 593         break;
 594       }
 595     }
 596
 597     TryConsumeToken(tok::ellipsis);
 598
 599     if (!TryConsumeToken(tok::comma))
 600       break;
 601   }
 602
 603   // An attribute must end ']]'.
 604   if (IsAttribute) {
 605     if (Tok.is(tok::r_square)) {
 606       ConsumeBracket();
 607       IsAttribute = Tok.is(tok::r_square);
 608     } else {
 609       IsAttribute = false;
 610     }
 611   }
 612
 613   PA.Revert();
 614
 615   if (IsAttribute)
 616     // Case 1: C++11 statement attribute.
 617     return CAK_AttributeSpecifier;
 618
 619   // Case 3: Message send.
 620   return CAK_NotAttributeSpecifier;
 621 }
 622
 623 Parser::TPResult Parser::TryParsePtrOperatorSeq() {
 624   while (true) {
 625     if (Tok.is(tok::coloncolon) || Tok.is(tok::identifier))
 626       if (TryAnnotateCXXScopeToken(true))
 627         return TPResult::Error;
 628
 629     if (Tok.is(tok::star) || Tok.is(tok::amp) || Tok.is(tok::caret) ||
 630         Tok.is(tok::ampamp) ||
 631         (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::star))) {
 632       // ptr-operator
 633       ConsumeToken();
 634       while (Tok.is(tok::kw_const)    ||
 635              Tok.is(tok::kw_volatile) ||
 636              Tok.is(tok::kw_restrict))
 637         ConsumeToken();
 638     } else {
 639       return TPResult::True;
 640     }
 641   }
 642 }
 643
 644 ///         operator-function-id:
 645 ///           'operator' operator
 646 ///
 647 ///         operator: one of
 648 ///           new  delete  new[]  delete[]  +  -  *  /  %  ^  [...]
 649 ///
 650 ///         conversion-function-id:
 651 ///           'operator' conversion-type-id
 652 ///
 653 ///         conversion-type-id:
 654 ///           type-specifier-seq conversion-declarator[opt]
 655 ///
 656 ///         conversion-declarator:
 657 ///           ptr-operator conversion-declarator[opt]
 658 ///
 659 ///         literal-operator-id:
 660 ///           'operator' string-literal identifier
 661 ///           'operator' user-defined-string-literal
 662 Parser::TPResult Parser::TryParseOperatorId() {
 663   assert(Tok.is(tok::kw_operator));
 664   ConsumeToken();
 665
 666   // Maybe this is an operator-function-id.
 667   switch (Tok.getKind()) {
 668   case tok::kw_new: case tok::kw_delete:
 669     ConsumeToken();
 670     if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
 671       ConsumeBracket();
 672       ConsumeBracket();
 673     }
 674     return TPResult::True;
 675
 676 #define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemOnly) \
 677   case tok::Token:
 678 #define OVERLOADED_OPERATOR_MULTI(Name, Spelling, Unary, Binary, MemOnly)
 679 #include "clang/Basic/OperatorKinds.def"
 680     ConsumeToken();
 681     return TPResult::True;
 682
 683   case tok::l_square:
 684     if (NextToken().is(tok::r_square)) {
 685       ConsumeBracket();
 686       ConsumeBracket();
 687       return TPResult::True;
 688     }
 689     break;
 690
 691   case tok::l_paren:
 692     if (NextToken().is(tok::r_paren)) {
 693       ConsumeParen();
 694       ConsumeParen();
 695       return TPResult::True;
 696     }
 697     break;
 698
 699   default:
 700     break;
 701   }
 702
 703   // Maybe this is a literal-operator-id.
 704   if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) {
 705     bool FoundUDSuffix = false;
 706     do {
 707       FoundUDSuffix |= Tok.hasUDSuffix();
 708       ConsumeStringToken();
 709     } while (isTokenStringLiteral());
 710
 711     if (!FoundUDSuffix) {
 712       if (Tok.is(tok::identifier))
 713         ConsumeToken();
 714       else
 715         return TPResult::Error;
 716     }
 717     return TPResult::True;
 718   }
 719
 720   // Maybe this is a conversion-function-id.
 721   bool AnyDeclSpecifiers = false;
 722   while (true) {
 723     TPResult TPR = isCXXDeclarationSpecifier();
 724     if (TPR == TPResult::Error)
 725       return TPR;
 726     if (TPR == TPResult::False) {
 727       if (!AnyDeclSpecifiers)
 728         return TPResult::Error;
 729       break;
 730     }
 731     if (TryConsumeDeclarationSpecifier() == TPResult::Error)
 732       return TPResult::Error;
 733     AnyDeclSpecifiers = true;
 734   }
 735   return TryParsePtrOperatorSeq();
 736 }
 737
 738 ///         declarator:
 739 ///           direct-declarator
 740 ///           ptr-operator declarator
 741 ///
 742 ///         direct-declarator:
 743 ///           declarator-id
 744 ///           direct-declarator '(' parameter-declaration-clause ')'
 745 ///                 cv-qualifier-seq[opt] exception-specification[opt]
 746 ///           direct-declarator '[' constant-expression[opt] ']'
 747 ///           '(' declarator ')'
 748 /// [GNU]     '(' attributes declarator ')'
 749 ///
 750 ///         abstract-declarator:
 751 ///           ptr-operator abstract-declarator[opt]
 752 ///           direct-abstract-declarator
 753 ///           ...
 754 ///
 755 ///         direct-abstract-declarator:
 756 ///           direct-abstract-declarator[opt]
 757 ///           '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
 758 ///                 exception-specification[opt]
 759 ///           direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
 760 ///           '(' abstract-declarator ')'
 761 ///
 762 ///         ptr-operator:
 763 ///           '*' cv-qualifier-seq[opt]
 764 ///           '&'
 765 /// [C++0x]   '&&'                                                        [TODO]
 766 ///           '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
 767 ///
 768 ///         cv-qualifier-seq:
 769 ///           cv-qualifier cv-qualifier-seq[opt]
 770 ///
 771 ///         cv-qualifier:
 772 ///           'const'
 773 ///           'volatile'
 774 ///
 775 ///         declarator-id:
 776 ///           '...'[opt] id-expression
 777 ///
 778 ///         id-expression:
 779 ///           unqualified-id
 780 ///           qualified-id                                                [TODO]
 781 ///
 782 ///         unqualified-id:
 783 ///           identifier
 784 ///           operator-function-id
 785 ///           conversion-function-id
 786 ///           literal-operator-id
 787 ///           '~' class-name                                              [TODO]
 788 ///           '~' decltype-specifier                                      [TODO]
 789 ///           template-id                                                 [TODO]
 790 ///
 791 Parser::TPResult Parser::TryParseDeclarator(bool mayBeAbstract,
 792                                             bool mayHaveIdentifier) {
 793   // declarator:
 794   //   direct-declarator
 795   //   ptr-operator declarator
 796   if (TryParsePtrOperatorSeq() == TPResult::Error)
 797     return TPResult::Error;
 798
 799   // direct-declarator:
 800   // direct-abstract-declarator:
 801   if (Tok.is(tok::ellipsis))
 802     ConsumeToken();
 803
 804   if ((Tok.is(tok::identifier) || Tok.is(tok::kw_operator) ||
 805        (Tok.is(tok::annot_cxxscope) && (NextToken().is(tok::identifier) ||
 806                                         NextToken().is(tok::kw_operator)))) &&
 807       mayHaveIdentifier) {
 808     // declarator-id
 809     if (Tok.is(tok::annot_cxxscope))
 810       ConsumeToken();
 811     else if (Tok.is(tok::identifier))
 812       TentativelyDeclaredIdentifiers.push_back(Tok.getIdentifierInfo());
 813     if (Tok.is(tok::kw_operator)) {
 814       if (TryParseOperatorId() == TPResult::Error)
 815         return TPResult::Error;
 816     } else
 817       ConsumeToken();
 818   } else if (Tok.is(tok::l_paren)) {
 819     ConsumeParen();
 820     if (mayBeAbstract &&
 821         (Tok.is(tok::r_paren) ||       // 'int()' is a function.
 822          // 'int(...)' is a function.
 823          (Tok.is(tok::ellipsis) && NextToken().is(tok::r_paren)) ||
 824          isDeclarationSpecifier())) {   // 'int(int)' is a function.
 825       // '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
 826       //        exception-specification[opt]
 827       TPResult TPR = TryParseFunctionDeclarator();
 828       if (TPR != TPResult::Ambiguous)
 829         return TPR;
 830     } else {
 831       // '(' declarator ')'
 832       // '(' attributes declarator ')'
 833       // '(' abstract-declarator ')'
 834       if (Tok.is(tok::kw___attribute) ||
 835           Tok.is(tok::kw___declspec) ||
 836           Tok.is(tok::kw___cdecl) ||
 837           Tok.is(tok::kw___stdcall) ||
 838           Tok.is(tok::kw___fastcall) ||
 839           Tok.is(tok::kw___thiscall) ||
 840           Tok.is(tok::kw___unaligned))
 841         return TPResult::True; // attributes indicate declaration
 842       TPResult TPR = TryParseDeclarator(mayBeAbstract, mayHaveIdentifier);
 843       if (TPR != TPResult::Ambiguous)
 844         return TPR;
 845       if (Tok.isNot(tok::r_paren))
 846         return TPResult::False;
 847       ConsumeParen();
 848     }
 849   } else if (!mayBeAbstract) {
 850     return TPResult::False;
 851   }
 852
 853   while (1) {
 854     TPResult TPR(TPResult::Ambiguous);
 855
 856     // abstract-declarator: ...
 857     if (Tok.is(tok::ellipsis))
 858       ConsumeToken();
 859
 860     if (Tok.is(tok::l_paren)) {
 861       // Check whether we have a function declarator or a possible ctor-style
 862       // initializer that follows the declarator. Note that ctor-style
 863       // initializers are not possible in contexts where abstract declarators
 864       // are allowed.
 865       if (!mayBeAbstract && !isCXXFunctionDeclarator())
 866         break;
 867
 868       // direct-declarator '(' parameter-declaration-clause ')'
 869       //        cv-qualifier-seq[opt] exception-specification[opt]
 870       ConsumeParen();
 871       TPR = TryParseFunctionDeclarator();
 872     } else if (Tok.is(tok::l_square)) {
 873       // direct-declarator '[' constant-expression[opt] ']'
 874       // direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
 875       TPR = TryParseBracketDeclarator();
 876     } else {
 877       break;
 878     }
 879
 880     if (TPR != TPResult::Ambiguous)
 881       return TPR;
 882   }
 883
 884   return TPResult::Ambiguous;
 885 }
 886
 887 Parser::TPResult
 888 Parser::isExpressionOrTypeSpecifierSimple(tok::TokenKind Kind) {
 889   switch (Kind) {
 890   // Obviously starts an expression.
 891   case tok::numeric_constant:
 892   case tok::char_constant:
 893   case tok::wide_char_constant:
 894   case tok::utf16_char_constant:
 895   case tok::utf32_char_constant:
 896   case tok::string_literal:
 897   case tok::wide_string_literal:
 898   case tok::utf8_string_literal:
 899   case tok::utf16_string_literal:
 900   case tok::utf32_string_literal:
 901   case tok::l_square:
 902   case tok::l_paren:
 903   case tok::amp:
 904   case tok::ampamp:
 905   case tok::star:
 906   case tok::plus:
 907   case tok::plusplus:
 908   case tok::minus:
 909   case tok::minusminus:
 910   case tok::tilde:
 911   case tok::exclaim:
 912   case tok::kw_sizeof:
 913   case tok::kw___func__:
 914   case tok::kw_const_cast:
 915   case tok::kw_delete:
 916   case tok::kw_dynamic_cast:
 917   case tok::kw_false:
 918   case tok::kw_new:
 919   case tok::kw_operator:
 920   case tok::kw_reinterpret_cast:
 921   case tok::kw_static_cast:
 922   case tok::kw_this:
 923   case tok::kw_throw:
 924   case tok::kw_true:
 925   case tok::kw_typeid:
 926   case tok::kw_alignof:
 927   case tok::kw_noexcept:
 928   case tok::kw_nullptr:
 929   case tok::kw__Alignof:
 930   case tok::kw___null:
 931   case tok::kw___alignof:
 932   case tok::kw___builtin_choose_expr:
 933   case tok::kw___builtin_offsetof:
 934   case tok::kw___builtin_va_arg:
 935   case tok::kw___imag:
 936   case tok::kw___real:
 937   case tok::kw___FUNCTION__:
 938   case tok::kw___FUNCDNAME__:
 939   case tok::kw___FUNCSIG__:
 940   case tok::kw_L__FUNCTION__:
 941   case tok::kw___PRETTY_FUNCTION__:
 942   case tok::kw___uuidof:
 943 #define TYPE_TRAIT(N,Spelling,K) \
 944   case tok::kw_##Spelling:
 945 #include "clang/Basic/TokenKinds.def"
 946     return TPResult::True;
 947
 948   // Obviously starts a type-specifier-seq:
 949   case tok::kw_char:
 950   case tok::kw_const:
 951   case tok::kw_double:
 952   case tok::kw_enum:
 953   case tok::kw_half:
 954   case tok::kw_float:
 955   case tok::kw_int:
 956   case tok::kw_long:
 957   case tok::kw___int64:
 958   case tok::kw___int128:
 959   case tok::kw_restrict:
 960   case tok::kw_short:
 961   case tok::kw_signed:
 962   case tok::kw_struct:
 963   case tok::kw_union:
 964   case tok::kw_unsigned:
 965   case tok::kw_void:
 966   case tok::kw_volatile:
 967   case tok::kw__Bool:
 968   case tok::kw__Complex:
 969   case tok::kw_class:
 970   case tok::kw_typename:
 971   case tok::kw_wchar_t:
 972   case tok::kw_char16_t:
 973   case tok::kw_char32_t:
 974   case tok::kw__Decimal32:
 975   case tok::kw__Decimal64:
 976   case tok::kw__Decimal128:
 977   case tok::kw___interface:
 978   case tok::kw___thread:
 979   case tok::kw_thread_local:
 980   case tok::kw__Thread_local:
 981   case tok::kw_typeof:
 982   case tok::kw___underlying_type:
 983   case tok::kw___cdecl:
 984   case tok::kw___stdcall:
 985   case tok::kw___fastcall:
 986   case tok::kw___thiscall:
 987   case tok::kw___unaligned:
 988   case tok::kw___vector:
 989   case tok::kw___pixel:
 990   case tok::kw__Atomic:
 991   case tok::kw___unknown_anytype:
 992     return TPResult::False;
 993
 994   default:
 995     break;
 996   }
 997
 998   return TPResult::Ambiguous;
 999 }
1000
1001 bool Parser::isTentativelyDeclared(IdentifierInfo *II) {
1002   return std::find(TentativelyDeclaredIdentifiers.begin(),
1003                    TentativelyDeclaredIdentifiers.end(), II)
1004       != TentativelyDeclaredIdentifiers.end();
1005 }
1006
1007 /// isCXXDeclarationSpecifier - Returns TPResult::True if it is a declaration
1008 /// specifier, TPResult::False if it is not, TPResult::Ambiguous if it could
1009 /// be either a decl-specifier or a function-style cast, and TPResult::Error
1010 /// if a parsing error was found and reported.
1011 ///
1012 /// If HasMissingTypename is provided, a name with a dependent scope specifier
1013 /// will be treated as ambiguous if the 'typename' keyword is missing. If this
1014 /// happens, *HasMissingTypename will be set to 'true'. This will also be used
1015 /// as an indicator that undeclared identifiers (which will trigger a later
1016 /// parse error) should be treated as types. Returns TPResult::Ambiguous in
1017 /// such cases.
1018 ///
1019 ///         decl-specifier:
1020 ///           storage-class-specifier
1021 ///           type-specifier
1022 ///           function-specifier
1023 ///           'friend'
1024 ///           'typedef'
1025 /// [C++11]   'constexpr'
1026 /// [GNU]     attributes declaration-specifiers[opt]
1027 ///
1028 ///         storage-class-specifier:
1029 ///           'register'
1030 ///           'static'
1031 ///           'extern'
1032 ///           'mutable'
1033 ///           'auto'
1034 /// [GNU]     '__thread'
1035 /// [C++11]   'thread_local'
1036 /// [C11]     '_Thread_local'
1037 ///
1038 ///         function-specifier:
1039 ///           'inline'
1040 ///           'virtual'
1041 ///           'explicit'
1042 ///
1043 ///         typedef-name:
1044 ///           identifier
1045 ///
1046 ///         type-specifier:
1047 ///           simple-type-specifier
1048 ///           class-specifier
1049 ///           enum-specifier
1050 ///           elaborated-type-specifier
1051 ///           typename-specifier
1052 ///           cv-qualifier
1053 ///
1054 ///         simple-type-specifier:
1055 ///           '::'[opt] nested-name-specifier[opt] type-name
1056 ///           '::'[opt] nested-name-specifier 'template'
1057 ///                 simple-template-id                              [TODO]
1058 ///           'char'
1059 ///           'wchar_t'
1060 ///           'bool'
1061 ///           'short'
1062 ///           'int'
1063 ///           'long'
1064 ///           'signed'
1065 ///           'unsigned'
1066 ///           'float'
1067 ///           'double'
1068 ///           'void'
1069 /// [GNU]     typeof-specifier
1070 /// [GNU]     '_Complex'
1071 /// [C++11]   'auto'
1072 /// [C++11]   'decltype' ( expression )
1073 /// [C++1y]   'decltype' ( 'auto' )
1074 ///
1075 ///         type-name:
1076 ///           class-name
1077 ///           enum-name
1078 ///           typedef-name
1079 ///
1080 ///         elaborated-type-specifier:
1081 ///           class-key '::'[opt] nested-name-specifier[opt] identifier
1082 ///           class-key '::'[opt] nested-name-specifier[opt] 'template'[opt]
1083 ///               simple-template-id
1084 ///           'enum' '::'[opt] nested-name-specifier[opt] identifier
1085 ///
1086 ///         enum-name:
1087 ///           identifier
1088 ///
1089 ///         enum-specifier:
1090 ///           'enum' identifier[opt] '{' enumerator-list[opt] '}'
1091 ///           'enum' identifier[opt] '{' enumerator-list ',' '}'
1092 ///
1093 ///         class-specifier:
1094 ///           class-head '{' member-specification[opt] '}'
1095 ///
1096 ///         class-head:
1097 ///           class-key identifier[opt] base-clause[opt]
1098 ///           class-key nested-name-specifier identifier base-clause[opt]
1099 ///           class-key nested-name-specifier[opt] simple-template-id
1100 ///               base-clause[opt]
1101 ///
1102 ///         class-key:
1103 ///           'class'
1104 ///           'struct'
1105 ///           'union'
1106 ///
1107 ///         cv-qualifier:
1108 ///           'const'
1109 ///           'volatile'
1110 /// [GNU]     restrict
1111 ///
1112 Parser::TPResult
1113 Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
1114                                   bool *HasMissingTypename) {
1115   switch (Tok.getKind()) {
1116   case tok::identifier: {
1117     // Check for need to substitute AltiVec __vector keyword
1118     // for "vector" identifier.
1119     if (TryAltiVecVectorToken())
1120       return TPResult::True;
1121
1122     const Token &Next = NextToken();
1123     // In 'foo bar', 'foo' is always a type name outside of Objective-C.
1124     if (!getLangOpts().ObjC1 && Next.is(tok::identifier))
1125       return TPResult::True;
1126
1127     if (Next.isNot(tok::coloncolon) && Next.isNot(tok::less)) {
1128       // Determine whether this is a valid expression. If not, we will hit
1129       // a parse error one way or another. In that case, tell the caller that
1130       // this is ambiguous. Typo-correct to type and expression keywords and
1131       // to types and identifiers, in order to try to recover from errors.
1132       CorrectionCandidateCallback TypoCorrection;
1133       TypoCorrection.WantRemainingKeywords = false;
1134       TypoCorrection.WantTypeSpecifiers = Next.isNot(tok::arrow);
1135       switch (TryAnnotateName(false /* no nested name specifier */,
1136                               &TypoCorrection)) {
1137       case ANK_Error:
1138         return TPResult::Error;
1139       case ANK_TentativeDecl:
1140         return TPResult::False;
1141       case ANK_TemplateName:
1142         // A bare type template-name which can't be a template template
1143         // argument is an error, and was probably intended to be a type.
1144         return GreaterThanIsOperator ? TPResult::True : TPResult::False;
1145       case ANK_Unresolved:
1146         return HasMissingTypename ? TPResult::Ambiguous : TPResult::False;
1147       case ANK_Success:
1148         break;
1149       }
1150       assert(Tok.isNot(tok::identifier) &&
1151              "TryAnnotateName succeeded without producing an annotation");
1152     } else {
1153       // This might possibly be a type with a dependent scope specifier and
1154       // a missing 'typename' keyword. Don't use TryAnnotateName in this case,
1155       // since it will annotate as a primary expression, and we want to use the
1156       // "missing 'typename'" logic.
1157       if (TryAnnotateTypeOrScopeToken())
1158         return TPResult::Error;
1159       // If annotation failed, assume it's a non-type.
1160       // FIXME: If this happens due to an undeclared identifier, treat it as
1161       // ambiguous.
1162       if (Tok.is(tok::identifier))
1163         return TPResult::False;
1164     }
1165
1166     // We annotated this token as something. Recurse to handle whatever we got.
1167     return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1168   }
1169
1170   case tok::kw_typename:  // typename T::type
1171     // Annotate typenames and C++ scope specifiers.  If we get one, just
1172     // recurse to handle whatever we get.
1173     if (TryAnnotateTypeOrScopeToken())
1174       return TPResult::Error;
1175     return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1176
1177   case tok::coloncolon: {    // ::foo::bar
1178     const Token &Next = NextToken();
1179     if (Next.is(tok::kw_new) ||    // ::new
1180         Next.is(tok::kw_delete))   // ::delete
1181       return TPResult::False;
1182   }
1183     // Fall through.
1184   case tok::kw_decltype:
1185     // Annotate typenames and C++ scope specifiers.  If we get one, just
1186     // recurse to handle whatever we get.
1187     if (TryAnnotateTypeOrScopeToken())
1188       return TPResult::Error;
1189     return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1190
1191     // decl-specifier:
1192     //   storage-class-specifier
1193     //   type-specifier
1194     //   function-specifier
1195     //   'friend'
1196     //   'typedef'
1197     //   'constexpr'
1198   case tok::kw_friend:
1199   case tok::kw_typedef:
1200   case tok::kw_constexpr:
1201     // storage-class-specifier
1202   case tok::kw_register:
1203   case tok::kw_static:
1204   case tok::kw_extern:
1205   case tok::kw_mutable:
1206   case tok::kw_auto:
1207   case tok::kw___thread:
1208   case tok::kw_thread_local:
1209   case tok::kw__Thread_local:
1210     // function-specifier
1211   case tok::kw_inline:
1212   case tok::kw_virtual:
1213   case tok::kw_explicit:
1214
1215     // Modules
1216   case tok::kw___module_private__:
1217
1218     // Debugger support
1219   case tok::kw___unknown_anytype:
1220
1221     // type-specifier:
1222     //   simple-type-specifier
1223     //   class-specifier
1224     //   enum-specifier
1225     //   elaborated-type-specifier
1226     //   typename-specifier
1227     //   cv-qualifier
1228
1229     // class-specifier
1230     // elaborated-type-specifier
1231   case tok::kw_class:
1232   case tok::kw_struct:
1233   case tok::kw_union:
1234   case tok::kw___interface:
1235     // enum-specifier
1236   case tok::kw_enum:
1237     // cv-qualifier
1238   case tok::kw_const:
1239   case tok::kw_volatile:
1240
1241     // GNU
1242   case tok::kw_restrict:
1243   case tok::kw__Complex:
1244   case tok::kw___attribute:
1245     return TPResult::True;
1246
1247     // Microsoft
1248   case tok::kw___declspec:
1249   case tok::kw___cdecl:
1250   case tok::kw___stdcall:
1251   case tok::kw___fastcall:
1252   case tok::kw___thiscall:
1253   case tok::kw___w64:
1254   case tok::kw___sptr:
1255   case tok::kw___uptr:
1256   case tok::kw___ptr64:
1257   case tok::kw___ptr32:
1258   case tok::kw___forceinline:
1259   case tok::kw___unaligned:
1260     return TPResult::True;
1261
1262     // Borland
1263   case tok::kw___pascal:
1264     return TPResult::True;
1265
1266     // AltiVec
1267   case tok::kw___vector:
1268     return TPResult::True;
1269
1270   case tok::annot_template_id: {
1271     TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
1272     if (TemplateId->Kind != TNK_Type_template)
1273       return TPResult::False;
1274     CXXScopeSpec SS;
1275     AnnotateTemplateIdTokenAsType();
1276     assert(Tok.is(tok::annot_typename));
1277     goto case_typename;
1278   }
1279
1280   case tok::annot_cxxscope: // foo::bar or ::foo::bar, but already parsed
1281     // We've already annotated a scope; try to annotate a type.
1282     if (TryAnnotateTypeOrScopeToken())
1283       return TPResult::Error;
1284     if (!Tok.is(tok::annot_typename)) {
1285       // If the next token is an identifier or a type qualifier, then this
1286       // can't possibly be a valid expression either.
1287       if (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier)) {
1288         CXXScopeSpec SS;
1289         Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
1290                                                      Tok.getAnnotationRange(),
1291                                                      SS);
1292         if (SS.getScopeRep() && SS.getScopeRep()->isDependent()) {
1293           TentativeParsingAction PA(*this);
1294           ConsumeToken();
1295           ConsumeToken();
1296           bool isIdentifier = Tok.is(tok::identifier);
1297           TPResult TPR = TPResult::False;
1298           if (!isIdentifier)
1299             TPR = isCXXDeclarationSpecifier(BracedCastResult,
1300                                             HasMissingTypename);
1301           PA.Revert();
1302
1303           if (isIdentifier ||
1304               TPR == TPResult::True || TPR == TPResult::Error)
1305             return TPResult::Error;
1306
1307           if (HasMissingTypename) {
1308             // We can't tell whether this is a missing 'typename' or a valid
1309             // expression.
1310             *HasMissingTypename = true;
1311             return TPResult::Ambiguous;
1312           }
1313         } else {
1314           // Try to resolve the name. If it doesn't exist, assume it was
1315           // intended to name a type and keep disambiguating.
1316           switch (TryAnnotateName(false /* SS is not dependent */)) {
1317           case ANK_Error:
1318             return TPResult::Error;
1319           case ANK_TentativeDecl:
1320             return TPResult::False;
1321           case ANK_TemplateName:
1322             // A bare type template-name which can't be a template template
1323             // argument is an error, and was probably intended to be a type.
1324             return GreaterThanIsOperator ? TPResult::True : TPResult::False;
1325           case ANK_Unresolved:
1326             return HasMissingTypename ? TPResult::Ambiguous
1327                                       : TPResult::False;
1328           case ANK_Success:
1329             // Annotated it, check again.
1330             assert(Tok.isNot(tok::annot_cxxscope) ||
1331                    NextToken().isNot(tok::identifier));
1332             return isCXXDeclarationSpecifier(BracedCastResult,
1333                                              HasMissingTypename);
1334           }
1335         }
1336       }
1337       return TPResult::False;
1338     }
1339     // If that succeeded, fallthrough into the generic simple-type-id case.
1340
1341     // The ambiguity resides in a simple-type-specifier/typename-specifier
1342     // followed by a '('. The '(' could either be the start of:
1343     //
1344     //   direct-declarator:
1345     //     '(' declarator ')'
1346     //
1347     //   direct-abstract-declarator:
1348     //     '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1349     //              exception-specification[opt]
1350     //     '(' abstract-declarator ')'
1351     //
1352     // or part of a function-style cast expression:
1353     //
1354     //     simple-type-specifier '(' expression-list[opt] ')'
1355     //
1356
1357     // simple-type-specifier:
1358
1359   case tok::annot_typename:
1360   case_typename:
1361     // In Objective-C, we might have a protocol-qualified type.
1362     if (getLangOpts().ObjC1 && NextToken().is(tok::less)) {
1363       // Tentatively parse the
1364       TentativeParsingAction PA(*this);
1365       ConsumeToken(); // The type token
1366
1367       TPResult TPR = TryParseProtocolQualifiers();
1368       bool isFollowedByParen = Tok.is(tok::l_paren);
1369       bool isFollowedByBrace = Tok.is(tok::l_brace);
1370
1371       PA.Revert();
1372
1373       if (TPR == TPResult::Error)
1374         return TPResult::Error;
1375
1376       if (isFollowedByParen)
1377         return TPResult::Ambiguous;
1378
1379       if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
1380         return BracedCastResult;
1381
1382       return TPResult::True;
1383     }
1384
1385   case tok::kw_char:
1386   case tok::kw_wchar_t:
1387   case tok::kw_char16_t:
1388   case tok::kw_char32_t:
1389   case tok::kw_bool:
1390   case tok::kw_short:
1391   case tok::kw_int:
1392   case tok::kw_long:
1393   case tok::kw___int64:
1394   case tok::kw___int128:
1395   case tok::kw_signed:
1396   case tok::kw_unsigned:
1397   case tok::kw_half:
1398   case tok::kw_float:
1399   case tok::kw_double:
1400   case tok::kw_void:
1401   case tok::annot_decltype:
1402     if (NextToken().is(tok::l_paren))
1403       return TPResult::Ambiguous;
1404
1405     // This is a function-style cast in all cases we disambiguate other than
1406     // one:
1407     //   struct S {
1408     //     enum E : int { a = 4 }; // enum
1409     //     enum E : int { 4 };     // bit-field
1410     //   };
1411     if (getLangOpts().CPlusPlus11 && NextToken().is(tok::l_brace))
1412       return BracedCastResult;
1413
1414     if (isStartOfObjCClassMessageMissingOpenBracket())
1415       return TPResult::False;
1416
1417     return TPResult::True;
1418
1419   // GNU typeof support.
1420   case tok::kw_typeof: {
1421     if (NextToken().isNot(tok::l_paren))
1422       return TPResult::True;
1423
1424     TentativeParsingAction PA(*this);
1425
1426     TPResult TPR = TryParseTypeofSpecifier();
1427     bool isFollowedByParen = Tok.is(tok::l_paren);
1428     bool isFollowedByBrace = Tok.is(tok::l_brace);
1429
1430     PA.Revert();
1431
1432     if (TPR == TPResult::Error)
1433       return TPResult::Error;
1434
1435     if (isFollowedByParen)
1436       return TPResult::Ambiguous;
1437
1438     if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
1439       return BracedCastResult;
1440
1441     return TPResult::True;
1442   }
1443
1444   // C++0x type traits support
1445   case tok::kw___underlying_type:
1446     return TPResult::True;
1447
1448   // C11 _Atomic
1449   case tok::kw__Atomic:
1450     return TPResult::True;
1451
1452   default:
1453     return TPResult::False;
1454   }
1455 }
1456
1457 bool Parser::isCXXDeclarationSpecifierAType() {
1458   switch (Tok.getKind()) {
1459     // typename-specifier
1460   case tok::annot_decltype:
1461   case tok::annot_template_id:
1462   case tok::annot_typename:
1463   case tok::kw_typeof:
1464   case tok::kw___underlying_type:
1465     return true;
1466
1467     // elaborated-type-specifier
1468   case tok::kw_class:
1469   case tok::kw_struct:
1470   case tok::kw_union:
1471   case tok::kw___interface:
1472   case tok::kw_enum:
1473     return true;
1474
1475     // simple-type-specifier
1476   case tok::kw_char:
1477   case tok::kw_wchar_t:
1478   case tok::kw_char16_t:
1479   case tok::kw_char32_t:
1480   case tok::kw_bool:
1481   case tok::kw_short:
1482   case tok::kw_int:
1483   case tok::kw_long:
1484   case tok::kw___int64:
1485   case tok::kw___int128:
1486   case tok::kw_signed:
1487   case tok::kw_unsigned:
1488   case tok::kw_half:
1489   case tok::kw_float:
1490   case tok::kw_double:
1491   case tok::kw_void:
1492   case tok::kw___unknown_anytype:
1493     return true;
1494
1495   case tok::kw_auto:
1496     return getLangOpts().CPlusPlus11;
1497
1498   case tok::kw__Atomic:
1499     // "_Atomic foo"
1500     return NextToken().is(tok::l_paren);
1501
1502   default:
1503     return false;
1504   }
1505 }
1506
1507 /// [GNU] typeof-specifier:
1508 ///         'typeof' '(' expressions ')'
1509 ///         'typeof' '(' type-name ')'
1510 ///
1511 Parser::TPResult Parser::TryParseTypeofSpecifier() {
1512   assert(Tok.is(tok::kw_typeof) && "Expected 'typeof'!");
1513   ConsumeToken();
1514
1515   assert(Tok.is(tok::l_paren) && "Expected '('");
1516   // Parse through the parens after 'typeof'.
1517   ConsumeParen();
1518   if (!SkipUntil(tok::r_paren, StopAtSemi))
1519     return TPResult::Error;
1520
1521   return TPResult::Ambiguous;
1522 }
1523
1524 /// [ObjC] protocol-qualifiers:
1525 ////         '<' identifier-list '>'
1526 Parser::TPResult Parser::TryParseProtocolQualifiers() {
1527   assert(Tok.is(tok::less) && "Expected '<' for qualifier list");
1528   ConsumeToken();
1529   do {
1530     if (Tok.isNot(tok::identifier))
1531       return TPResult::Error;
1532     ConsumeToken();
1533
1534     if (Tok.is(tok::comma)) {
1535       ConsumeToken();
1536       continue;
1537     }
1538
1539     if (Tok.is(tok::greater)) {
1540       ConsumeToken();
1541       return TPResult::Ambiguous;
1542     }
1543   } while (false);
1544
1545   return TPResult::Error;
1546 }
1547
1548 /// isCXXFunctionDeclarator - Disambiguates between a function declarator or
1549 /// a constructor-style initializer, when parsing declaration statements.
1550 /// Returns true for function declarator and false for constructor-style
1551 /// initializer.
1552 /// If during the disambiguation process a parsing error is encountered,
1553 /// the function returns true to let the declaration parsing code handle it.
1554 ///
1555 /// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1556 ///         exception-specification[opt]
1557 ///
1558 bool Parser::isCXXFunctionDeclarator(bool *IsAmbiguous) {
1559
1560   // C++ 8.2p1:
1561   // The ambiguity arising from the similarity between a function-style cast and
1562   // a declaration mentioned in 6.8 can also occur in the context of a
1563   // declaration. In that context, the choice is between a function declaration
1564   // with a redundant set of parentheses around a parameter name and an object
1565   // declaration with a function-style cast as the initializer. Just as for the
1566   // ambiguities mentioned in 6.8, the resolution is to consider any construct
1567   // that could possibly be a declaration a declaration.
1568
1569   TentativeParsingAction PA(*this);
1570
1571   ConsumeParen();
1572   bool InvalidAsDeclaration = false;
1573   TPResult TPR = TryParseParameterDeclarationClause(&InvalidAsDeclaration);
1574   if (TPR == TPResult::Ambiguous) {
1575     if (Tok.isNot(tok::r_paren))
1576       TPR = TPResult::False;
1577     else {
1578       const Token &Next = NextToken();
1579       if (Next.is(tok::amp) || Next.is(tok::ampamp) ||
1580           Next.is(tok::kw_const) || Next.is(tok::kw_volatile) ||
1581           Next.is(tok::kw_throw) || Next.is(tok::kw_noexcept) ||
1582           Next.is(tok::l_square) || isCXX11VirtSpecifier(Next) ||
1583           Next.is(tok::l_brace) || Next.is(tok::kw_try) ||
1584           Next.is(tok::equal) || Next.is(tok::arrow))
1585         // The next token cannot appear after a constructor-style initializer,
1586         // and can appear next in a function definition. This must be a function
1587         // declarator.
1588         TPR = TPResult::True;
1589       else if (InvalidAsDeclaration)
1590         // Use the absence of 'typename' as a tie-breaker.
1591         TPR = TPResult::False;
1592     }
1593   }
1594
1595   PA.Revert();
1596
1597   if (IsAmbiguous && TPR == TPResult::Ambiguous)
1598     *IsAmbiguous = true;
1599
1600   // In case of an error, let the declaration parsing code handle it.
1601   return TPR != TPResult::False;
1602 }
1603
1604 /// parameter-declaration-clause:
1605 ///   parameter-declaration-list[opt] '...'[opt]
1606 ///   parameter-declaration-list ',' '...'
1607 ///
1608 /// parameter-declaration-list:
1609 ///   parameter-declaration
1610 ///   parameter-declaration-list ',' parameter-declaration
1611 ///
1612 /// parameter-declaration:
1613 ///   attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
1614 ///   attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
1615 ///     '=' assignment-expression
1616 ///   attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
1617 ///     attributes[opt]
1618 ///   attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
1619 ///     attributes[opt] '=' assignment-expression
1620 ///
1621 Parser::TPResult
1622 Parser::TryParseParameterDeclarationClause(bool *InvalidAsDeclaration,
1623                                            bool VersusTemplateArgument) {
1624
1625   if (Tok.is(tok::r_paren))
1626     return TPResult::Ambiguous;
1627
1628   //   parameter-declaration-list[opt] '...'[opt]
1629   //   parameter-declaration-list ',' '...'
1630   //
1631   // parameter-declaration-list:
1632   //   parameter-declaration
1633   //   parameter-declaration-list ',' parameter-declaration
1634   //
1635   while (1) {
1636     // '...'[opt]
1637     if (Tok.is(tok::ellipsis)) {
1638       ConsumeToken();
1639       if (Tok.is(tok::r_paren))
1640         return TPResult::True; // '...)' is a sign of a function declarator.
1641       else
1642         return TPResult::False;
1643     }
1644
1645     // An attribute-specifier-seq here is a sign of a function declarator.
1646     if (isCXX11AttributeSpecifier(/*Disambiguate*/false,
1647                                   /*OuterMightBeMessageSend*/true))
1648       return TPResult::True;
1649
1650     ParsedAttributes attrs(AttrFactory);
1651     MaybeParseMicrosoftAttributes(attrs);
1652
1653     // decl-specifier-seq
1654     // A parameter-declaration's initializer must be preceded by an '=', so
1655     // decl-specifier-seq '{' is not a parameter in C++11.
1656     TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
1657                                              InvalidAsDeclaration);
1658
1659     if (VersusTemplateArgument && TPR == TPResult::True) {
1660       // Consume the decl-specifier-seq. We have to look past it, since a
1661       // type-id might appear here in a template argument.
1662       bool SeenType = false;
1663       do {
1664         SeenType |= isCXXDeclarationSpecifierAType();
1665         if (TryConsumeDeclarationSpecifier() == TPResult::Error)
1666           return TPResult::Error;
1667
1668         // If we see a parameter name, this can't be a template argument.
1669         if (SeenType && Tok.is(tok::identifier))
1670           return TPResult::True;
1671
1672         TPR = isCXXDeclarationSpecifier(TPResult::False,
1673                                         InvalidAsDeclaration);
1674         if (TPR == TPResult::Error)
1675           return TPR;
1676       } while (TPR != TPResult::False);
1677     } else if (TPR == TPResult::Ambiguous) {
1678       // Disambiguate what follows the decl-specifier.
1679       if (TryConsumeDeclarationSpecifier() == TPResult::Error)
1680         return TPResult::Error;
1681     } else
1682       return TPR;
1683
1684     // declarator
1685     // abstract-declarator[opt]
1686     TPR = TryParseDeclarator(true/*mayBeAbstract*/);
1687     if (TPR != TPResult::Ambiguous)
1688       return TPR;
1689
1690     // [GNU] attributes[opt]
1691     if (Tok.is(tok::kw___attribute))
1692       return TPResult::True;
1693
1694     // If we're disambiguating a template argument in a default argument in
1695     // a class definition versus a parameter declaration, an '=' here
1696     // disambiguates the parse one way or the other.
1697     // If this is a parameter, it must have a default argument because
1698     //   (a) the previous parameter did, and
1699     //   (b) this must be the first declaration of the function, so we can't
1700     //       inherit any default arguments from elsewhere.
1701     // If we see an ')', then we've reached the end of a
1702     // parameter-declaration-clause, and the last param is missing its default
1703     // argument.
1704     if (VersusTemplateArgument)
1705       return (Tok.is(tok::equal) || Tok.is(tok::r_paren)) ? TPResult::True
1706                                                           : TPResult::False;
1707
1708     if (Tok.is(tok::equal)) {
1709       // '=' assignment-expression
1710       // Parse through assignment-expression.
1711       // FIXME: assignment-expression may contain an unparenthesized comma.
1712       if (!SkipUntil(tok::comma, tok::r_paren, StopAtSemi | StopBeforeMatch))
1713         return TPResult::Error;
1714     }
1715
1716     if (Tok.is(tok::ellipsis)) {
1717       ConsumeToken();
1718       if (Tok.is(tok::r_paren))
1719         return TPResult::True; // '...)' is a sign of a function declarator.
1720       else
1721         return TPResult::False;
1722     }
1723
1724     if (!TryConsumeToken(tok::comma))
1725       break;
1726   }
1727
1728   return TPResult::Ambiguous;
1729 }
1730
1731 /// TryParseFunctionDeclarator - We parsed a '(' and we want to try to continue
1732 /// parsing as a function declarator.
1733 /// If TryParseFunctionDeclarator fully parsed the function declarator, it will
1734 /// return TPResult::Ambiguous, otherwise it will return either False() or
1735 /// Error().
1736 ///
1737 /// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1738 ///         exception-specification[opt]
1739 ///
1740 /// exception-specification:
1741 ///   'throw' '(' type-id-list[opt] ')'
1742 ///
1743 Parser::TPResult Parser::TryParseFunctionDeclarator() {
1744
1745   // The '(' is already parsed.
1746
1747   TPResult TPR = TryParseParameterDeclarationClause();
1748   if (TPR == TPResult::Ambiguous && Tok.isNot(tok::r_paren))
1749     TPR = TPResult::False;
1750
1751   if (TPR == TPResult::False || TPR == TPResult::Error)
1752     return TPR;
1753
1754   // Parse through the parens.
1755   if (!SkipUntil(tok::r_paren, StopAtSemi))
1756     return TPResult::Error;
1757
1758   // cv-qualifier-seq
1759   while (Tok.is(tok::kw_const)    ||
1760          Tok.is(tok::kw_volatile) ||
1761          Tok.is(tok::kw_restrict)   )
1762     ConsumeToken();
1763
1764   // ref-qualifier[opt]
1765   if (Tok.is(tok::amp) || Tok.is(tok::ampamp))
1766     ConsumeToken();
1767
1768   // exception-specification
1769   if (Tok.is(tok::kw_throw)) {
1770     ConsumeToken();
1771     if (Tok.isNot(tok::l_paren))
1772       return TPResult::Error;
1773
1774     // Parse through the parens after 'throw'.
1775     ConsumeParen();
1776     if (!SkipUntil(tok::r_paren, StopAtSemi))
1777       return TPResult::Error;
1778   }
1779   if (Tok.is(tok::kw_noexcept)) {
1780     ConsumeToken();
1781     // Possibly an expression as well.
1782     if (Tok.is(tok::l_paren)) {
1783       // Find the matching rparen.
1784       ConsumeParen();
1785       if (!SkipUntil(tok::r_paren, StopAtSemi))
1786         return TPResult::Error;
1787     }
1788   }
1789
1790   return TPResult::Ambiguous;
1791 }
1792
1793 /// '[' constant-expression[opt] ']'
1794 ///
1795 Parser::TPResult Parser::TryParseBracketDeclarator() {
1796   ConsumeBracket();
1797   if (!SkipUntil(tok::r_square, StopAtSemi))
1798     return TPResult::Error;
1799
1800   return TPResult::Ambiguous;
1801 }