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