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