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