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