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