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