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