1 //===--- ParseExprCXX.cpp - C++ Expression 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 Expression parsing implementation for C++. 11 // 12 //===----------------------------------------------------------------------===// 13 #include "clang/AST/ASTContext.h" 14 #include "RAIIObjectsForParser.h" 15 #include "clang/AST/DeclTemplate.h" 16 #include "clang/Basic/PrettyStackTrace.h" 17 #include "clang/Lex/LiteralSupport.h" 18 #include "clang/Parse/ParseDiagnostic.h" 19 #include "clang/Parse/Parser.h" 20 #include "clang/Sema/DeclSpec.h" 21 #include "clang/Sema/ParsedTemplate.h" 22 #include "clang/Sema/Scope.h" 23 #include "llvm/Support/ErrorHandling.h" 24 25 26 using namespace clang; 27 28 static int SelectDigraphErrorMessage(tok::TokenKind Kind) { 29 switch (Kind) { 30 // template name 31 case tok::unknown: return 0; 32 // casts 33 case tok::kw_const_cast: return 1; 34 case tok::kw_dynamic_cast: return 2; 35 case tok::kw_reinterpret_cast: return 3; 36 case tok::kw_static_cast: return 4; 37 default: 38 llvm_unreachable("Unknown type for digraph error message."); 39 } 40 } 41 42 // Are the two tokens adjacent in the same source file? 43 bool Parser::areTokensAdjacent(const Token &First, const Token &Second) { 44 SourceManager &SM = PP.getSourceManager(); 45 SourceLocation FirstLoc = SM.getSpellingLoc(First.getLocation()); 46 SourceLocation FirstEnd = FirstLoc.getLocWithOffset(First.getLength()); 47 return FirstEnd == SM.getSpellingLoc(Second.getLocation()); 48 } 49 50 // Suggest fixit for "<::" after a cast. 51 static void FixDigraph(Parser &P, Preprocessor &PP, Token &DigraphToken, 52 Token &ColonToken, tok::TokenKind Kind, bool AtDigraph) { 53 // Pull '<:' and ':' off token stream. 54 if (!AtDigraph) 55 PP.Lex(DigraphToken); 56 PP.Lex(ColonToken); 57 58 SourceRange Range; 59 Range.setBegin(DigraphToken.getLocation()); 60 Range.setEnd(ColonToken.getLocation()); 61 P.Diag(DigraphToken.getLocation(), diag::err_missing_whitespace_digraph) 62 << SelectDigraphErrorMessage(Kind) 63 << FixItHint::CreateReplacement(Range, "< ::"); 64 65 // Update token information to reflect their change in token type. 66 ColonToken.setKind(tok::coloncolon); 67 ColonToken.setLocation(ColonToken.getLocation().getLocWithOffset(-1)); 68 ColonToken.setLength(2); 69 DigraphToken.setKind(tok::less); 70 DigraphToken.setLength(1); 71 72 // Push new tokens back to token stream. 73 PP.EnterToken(ColonToken); 74 if (!AtDigraph) 75 PP.EnterToken(DigraphToken); 76 } 77 78 // Check for '<::' which should be '< ::' instead of '[:' when following 79 // a template name. 80 void Parser::CheckForTemplateAndDigraph(Token &Next, ParsedType ObjectType, 81 bool EnteringContext, 82 IdentifierInfo &II, CXXScopeSpec &SS) { 83 if (!Next.is(tok::l_square) || Next.getLength() != 2) 84 return; 85 86 Token SecondToken = GetLookAheadToken(2); 87 if (!SecondToken.is(tok::colon) || !areTokensAdjacent(Next, SecondToken)) 88 return; 89 90 TemplateTy Template; 91 UnqualifiedId TemplateName; 92 TemplateName.setIdentifier(&II, Tok.getLocation()); 93 bool MemberOfUnknownSpecialization; 94 if (!Actions.isTemplateName(getCurScope(), SS, /*hasTemplateKeyword=*/false, 95 TemplateName, ObjectType, EnteringContext, 96 Template, MemberOfUnknownSpecialization)) 97 return; 98 99 FixDigraph(*this, PP, Next, SecondToken, tok::unknown, 100 /*AtDigraph*/false); 101 } 102 103 /// \brief Emits an error for a left parentheses after a double colon. 104 /// 105 /// When a '(' is found after a '::', emit an error. Attempt to fix the token 106 /// stream by removing the '(', and the matching ')' if found. 107 void Parser::CheckForLParenAfterColonColon() { 108 if (!Tok.is(tok::l_paren)) 109 return; 110 111 Token LParen = Tok; 112 Token NextTok = GetLookAheadToken(1); 113 Token StarTok = NextTok; 114 // Check for (identifier or (*identifier 115 Token IdentifierTok = StarTok.is(tok::star) ? GetLookAheadToken(2) : StarTok; 116 if (IdentifierTok.isNot(tok::identifier)) 117 return; 118 // Eat the '('. 119 ConsumeParen(); 120 Token RParen; 121 RParen.setLocation(SourceLocation()); 122 // Do we have a ')' ? 123 NextTok = StarTok.is(tok::star) ? GetLookAheadToken(2) : GetLookAheadToken(1); 124 if (NextTok.is(tok::r_paren)) { 125 RParen = NextTok; 126 // Eat the '*' if it is present. 127 if (StarTok.is(tok::star)) 128 ConsumeToken(); 129 // Eat the identifier. 130 ConsumeToken(); 131 // Add the identifier token back. 132 PP.EnterToken(IdentifierTok); 133 // Add the '*' back if it was present. 134 if (StarTok.is(tok::star)) 135 PP.EnterToken(StarTok); 136 // Eat the ')'. 137 ConsumeParen(); 138 } 139 140 Diag(LParen.getLocation(), diag::err_paren_after_colon_colon) 141 << FixItHint::CreateRemoval(LParen.getLocation()) 142 << FixItHint::CreateRemoval(RParen.getLocation()); 143 } 144 145 /// \brief Parse global scope or nested-name-specifier if present. 146 /// 147 /// Parses a C++ global scope specifier ('::') or nested-name-specifier (which 148 /// may be preceded by '::'). Note that this routine will not parse ::new or 149 /// ::delete; it will just leave them in the token stream. 150 /// 151 /// '::'[opt] nested-name-specifier 152 /// '::' 153 /// 154 /// nested-name-specifier: 155 /// type-name '::' 156 /// namespace-name '::' 157 /// nested-name-specifier identifier '::' 158 /// nested-name-specifier 'template'[opt] simple-template-id '::' 159 /// 160 /// 161 /// \param SS the scope specifier that will be set to the parsed 162 /// nested-name-specifier (or empty) 163 /// 164 /// \param ObjectType if this nested-name-specifier is being parsed following 165 /// the "." or "->" of a member access expression, this parameter provides the 166 /// type of the object whose members are being accessed. 167 /// 168 /// \param EnteringContext whether we will be entering into the context of 169 /// the nested-name-specifier after parsing it. 170 /// 171 /// \param MayBePseudoDestructor When non-NULL, points to a flag that 172 /// indicates whether this nested-name-specifier may be part of a 173 /// pseudo-destructor name. In this case, the flag will be set false 174 /// if we don't actually end up parsing a destructor name. Moreorover, 175 /// if we do end up determining that we are parsing a destructor name, 176 /// the last component of the nested-name-specifier is not parsed as 177 /// part of the scope specifier. 178 /// 179 /// \param IsTypename If \c true, this nested-name-specifier is known to be 180 /// part of a type name. This is used to improve error recovery. 181 /// 182 /// \param LastII When non-NULL, points to an IdentifierInfo* that will be 183 /// filled in with the leading identifier in the last component of the 184 /// nested-name-specifier, if any. 185 /// 186 /// \returns true if there was an error parsing a scope specifier 187 bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS, 188 ParsedType ObjectType, 189 bool EnteringContext, 190 bool *MayBePseudoDestructor, 191 bool IsTypename, 192 IdentifierInfo **LastII) { 193 assert(getLangOpts().CPlusPlus && 194 "Call sites of this function should be guarded by checking for C++"); 195 196 if (Tok.is(tok::annot_cxxscope)) { 197 assert(!LastII && "want last identifier but have already annotated scope"); 198 assert(!MayBePseudoDestructor && "unexpected annot_cxxscope"); 199 Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(), 200 Tok.getAnnotationRange(), 201 SS); 202 ConsumeToken(); 203 return false; 204 } 205 206 if (Tok.is(tok::annot_template_id)) { 207 // If the current token is an annotated template id, it may already have 208 // a scope specifier. Restore it. 209 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); 210 SS = TemplateId->SS; 211 } 212 213 // Has to happen before any "return false"s in this function. 214 bool CheckForDestructor = false; 215 if (MayBePseudoDestructor && *MayBePseudoDestructor) { 216 CheckForDestructor = true; 217 *MayBePseudoDestructor = false; 218 } 219 220 if (LastII) 221 *LastII = nullptr; 222 223 bool HasScopeSpecifier = false; 224 225 if (Tok.is(tok::coloncolon)) { 226 // ::new and ::delete aren't nested-name-specifiers. 227 tok::TokenKind NextKind = NextToken().getKind(); 228 if (NextKind == tok::kw_new || NextKind == tok::kw_delete) 229 return false; 230 231 if (NextKind == tok::l_brace) { 232 // It is invalid to have :: {, consume the scope qualifier and pretend 233 // like we never saw it. 234 Diag(ConsumeToken(), diag::err_expected) << tok::identifier; 235 } else { 236 // '::' - Global scope qualifier. 237 if (Actions.ActOnCXXGlobalScopeSpecifier(ConsumeToken(), SS)) 238 return true; 239 240 CheckForLParenAfterColonColon(); 241 242 HasScopeSpecifier = true; 243 } 244 } 245 246 if (Tok.is(tok::kw___super)) { 247 SourceLocation SuperLoc = ConsumeToken(); 248 if (!Tok.is(tok::coloncolon)) { 249 Diag(Tok.getLocation(), diag::err_expected_coloncolon_after_super); 250 return true; 251 } 252 253 return Actions.ActOnSuperScopeSpecifier(SuperLoc, ConsumeToken(), SS); 254 } 255 256 if (!HasScopeSpecifier && 257 (Tok.is(tok::kw_decltype) || Tok.is(tok::annot_decltype))) { 258 DeclSpec DS(AttrFactory); 259 SourceLocation DeclLoc = Tok.getLocation(); 260 SourceLocation EndLoc = ParseDecltypeSpecifier(DS); 261 262 SourceLocation CCLoc; 263 if (!TryConsumeToken(tok::coloncolon, CCLoc)) { 264 AnnotateExistingDecltypeSpecifier(DS, DeclLoc, EndLoc); 265 return false; 266 } 267 268 if (Actions.ActOnCXXNestedNameSpecifierDecltype(SS, DS, CCLoc)) 269 SS.SetInvalid(SourceRange(DeclLoc, CCLoc)); 270 271 HasScopeSpecifier = true; 272 } 273 274 while (true) { 275 if (HasScopeSpecifier) { 276 // C++ [basic.lookup.classref]p5: 277 // If the qualified-id has the form 278 // 279 // ::class-name-or-namespace-name::... 280 // 281 // the class-name-or-namespace-name is looked up in global scope as a 282 // class-name or namespace-name. 283 // 284 // To implement this, we clear out the object type as soon as we've 285 // seen a leading '::' or part of a nested-name-specifier. 286 ObjectType = ParsedType(); 287 288 if (Tok.is(tok::code_completion)) { 289 // Code completion for a nested-name-specifier, where the code 290 // code completion token follows the '::'. 291 Actions.CodeCompleteQualifiedId(getCurScope(), SS, EnteringContext); 292 // Include code completion token into the range of the scope otherwise 293 // when we try to annotate the scope tokens the dangling code completion 294 // token will cause assertion in 295 // Preprocessor::AnnotatePreviousCachedTokens. 296 SS.setEndLoc(Tok.getLocation()); 297 cutOffParsing(); 298 return true; 299 } 300 } 301 302 // nested-name-specifier: 303 // nested-name-specifier 'template'[opt] simple-template-id '::' 304 305 // Parse the optional 'template' keyword, then make sure we have 306 // 'identifier <' after it. 307 if (Tok.is(tok::kw_template)) { 308 // If we don't have a scope specifier or an object type, this isn't a 309 // nested-name-specifier, since they aren't allowed to start with 310 // 'template'. 311 if (!HasScopeSpecifier && !ObjectType) 312 break; 313 314 TentativeParsingAction TPA(*this); 315 SourceLocation TemplateKWLoc = ConsumeToken(); 316 317 UnqualifiedId TemplateName; 318 if (Tok.is(tok::identifier)) { 319 // Consume the identifier. 320 TemplateName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation()); 321 ConsumeToken(); 322 } else if (Tok.is(tok::kw_operator)) { 323 // We don't need to actually parse the unqualified-id in this case, 324 // because a simple-template-id cannot start with 'operator', but 325 // go ahead and parse it anyway for consistency with the case where 326 // we already annotated the template-id. 327 if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, 328 TemplateName)) { 329 TPA.Commit(); 330 break; 331 } 332 333 if (TemplateName.getKind() != UnqualifiedId::IK_OperatorFunctionId && 334 TemplateName.getKind() != UnqualifiedId::IK_LiteralOperatorId) { 335 Diag(TemplateName.getSourceRange().getBegin(), 336 diag::err_id_after_template_in_nested_name_spec) 337 << TemplateName.getSourceRange(); 338 TPA.Commit(); 339 break; 340 } 341 } else { 342 TPA.Revert(); 343 break; 344 } 345 346 // If the next token is not '<', we have a qualified-id that refers 347 // to a template name, such as T::template apply, but is not a 348 // template-id. 349 if (Tok.isNot(tok::less)) { 350 TPA.Revert(); 351 break; 352 } 353 354 // Commit to parsing the template-id. 355 TPA.Commit(); 356 TemplateTy Template; 357 if (TemplateNameKind TNK 358 = Actions.ActOnDependentTemplateName(getCurScope(), 359 SS, TemplateKWLoc, TemplateName, 360 ObjectType, EnteringContext, 361 Template)) { 362 if (AnnotateTemplateIdToken(Template, TNK, SS, TemplateKWLoc, 363 TemplateName, false)) 364 return true; 365 } else 366 return true; 367 368 continue; 369 } 370 371 if (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) { 372 // We have 373 // 374 // template-id '::' 375 // 376 // So we need to check whether the template-id is a simple-template-id of 377 // the right kind (it should name a type or be dependent), and then 378 // convert it into a type within the nested-name-specifier. 379 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); 380 if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) { 381 *MayBePseudoDestructor = true; 382 return false; 383 } 384 385 if (LastII) 386 *LastII = TemplateId->Name; 387 388 // Consume the template-id token. 389 ConsumeToken(); 390 391 assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!"); 392 SourceLocation CCLoc = ConsumeToken(); 393 394 HasScopeSpecifier = true; 395 396 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(), 397 TemplateId->NumArgs); 398 399 if (Actions.ActOnCXXNestedNameSpecifier(getCurScope(), 400 SS, 401 TemplateId->TemplateKWLoc, 402 TemplateId->Template, 403 TemplateId->TemplateNameLoc, 404 TemplateId->LAngleLoc, 405 TemplateArgsPtr, 406 TemplateId->RAngleLoc, 407 CCLoc, 408 EnteringContext)) { 409 SourceLocation StartLoc 410 = SS.getBeginLoc().isValid()? SS.getBeginLoc() 411 : TemplateId->TemplateNameLoc; 412 SS.SetInvalid(SourceRange(StartLoc, CCLoc)); 413 } 414 415 continue; 416 } 417 418 // The rest of the nested-name-specifier possibilities start with 419 // tok::identifier. 420 if (Tok.isNot(tok::identifier)) 421 break; 422 423 IdentifierInfo &II = *Tok.getIdentifierInfo(); 424 425 // nested-name-specifier: 426 // type-name '::' 427 // namespace-name '::' 428 // nested-name-specifier identifier '::' 429 Token Next = NextToken(); 430 431 // If we get foo:bar, this is almost certainly a typo for foo::bar. Recover 432 // and emit a fixit hint for it. 433 if (Next.is(tok::colon) && !ColonIsSacred) { 434 if (Actions.IsInvalidUnlessNestedName(getCurScope(), SS, II, 435 Tok.getLocation(), 436 Next.getLocation(), ObjectType, 437 EnteringContext) && 438 // If the token after the colon isn't an identifier, it's still an 439 // error, but they probably meant something else strange so don't 440 // recover like this. 441 PP.LookAhead(1).is(tok::identifier)) { 442 Diag(Next, diag::err_unexpected_colon_in_nested_name_spec) 443 << FixItHint::CreateReplacement(Next.getLocation(), "::"); 444 // Recover as if the user wrote '::'. 445 Next.setKind(tok::coloncolon); 446 } 447 } 448 449 if (Next.is(tok::coloncolon) && GetLookAheadToken(2).is(tok::l_brace)) { 450 // It is invalid to have :: {, consume the scope qualifier and pretend 451 // like we never saw it. 452 Token Identifier = Tok; // Stash away the identifier. 453 ConsumeToken(); // Eat the identifier, current token is now '::'. 454 Diag(PP.getLocForEndOfToken(ConsumeToken()), diag::err_expected) 455 << tok::identifier; 456 UnconsumeToken(Identifier); // Stick the identifier back. 457 Next = NextToken(); // Point Next at the '{' token. 458 } 459 460 if (Next.is(tok::coloncolon)) { 461 if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde) && 462 !Actions.isNonTypeNestedNameSpecifier( 463 getCurScope(), SS, Tok.getLocation(), II, ObjectType)) { 464 *MayBePseudoDestructor = true; 465 return false; 466 } 467 468 if (ColonIsSacred) { 469 const Token &Next2 = GetLookAheadToken(2); 470 if (Next2.is(tok::kw_private) || Next2.is(tok::kw_protected) || 471 Next2.is(tok::kw_public) || Next2.is(tok::kw_virtual)) { 472 Diag(Next2, diag::err_unexpected_token_in_nested_name_spec) 473 << Next2.getName() 474 << FixItHint::CreateReplacement(Next.getLocation(), ":"); 475 Token ColonColon; 476 PP.Lex(ColonColon); 477 ColonColon.setKind(tok::colon); 478 PP.EnterToken(ColonColon); 479 break; 480 } 481 } 482 483 if (LastII) 484 *LastII = &II; 485 486 // We have an identifier followed by a '::'. Lookup this name 487 // as the name in a nested-name-specifier. 488 Token Identifier = Tok; 489 SourceLocation IdLoc = ConsumeToken(); 490 assert((Tok.is(tok::coloncolon) || Tok.is(tok::colon)) && 491 "NextToken() not working properly!"); 492 Token ColonColon = Tok; 493 SourceLocation CCLoc = ConsumeToken(); 494 495 CheckForLParenAfterColonColon(); 496 497 bool IsCorrectedToColon = false; 498 bool *CorrectionFlagPtr = ColonIsSacred ? &IsCorrectedToColon : nullptr; 499 if (Actions.ActOnCXXNestedNameSpecifier(getCurScope(), II, IdLoc, CCLoc, 500 ObjectType, EnteringContext, SS, 501 false, CorrectionFlagPtr)) { 502 // Identifier is not recognized as a nested name, but we can have 503 // mistyped '::' instead of ':'. 504 if (CorrectionFlagPtr && IsCorrectedToColon) { 505 ColonColon.setKind(tok::colon); 506 PP.EnterToken(Tok); 507 PP.EnterToken(ColonColon); 508 Tok = Identifier; 509 break; 510 } 511 SS.SetInvalid(SourceRange(IdLoc, CCLoc)); 512 } 513 HasScopeSpecifier = true; 514 continue; 515 } 516 517 CheckForTemplateAndDigraph(Next, ObjectType, EnteringContext, II, SS); 518 519 // nested-name-specifier: 520 // type-name '<' 521 if (Next.is(tok::less)) { 522 TemplateTy Template; 523 UnqualifiedId TemplateName; 524 TemplateName.setIdentifier(&II, Tok.getLocation()); 525 bool MemberOfUnknownSpecialization; 526 if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS, 527 /*hasTemplateKeyword=*/false, 528 TemplateName, 529 ObjectType, 530 EnteringContext, 531 Template, 532 MemberOfUnknownSpecialization)) { 533 // We have found a template name, so annotate this token 534 // with a template-id annotation. We do not permit the 535 // template-id to be translated into a type annotation, 536 // because some clients (e.g., the parsing of class template 537 // specializations) still want to see the original template-id 538 // token. 539 ConsumeToken(); 540 if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(), 541 TemplateName, false)) 542 return true; 543 continue; 544 } 545 546 if (MemberOfUnknownSpecialization && (ObjectType || SS.isSet()) && 547 (IsTypename || IsTemplateArgumentList(1))) { 548 // We have something like t::getAs<T>, where getAs is a 549 // member of an unknown specialization. However, this will only 550 // parse correctly as a template, so suggest the keyword 'template' 551 // before 'getAs' and treat this as a dependent template name. 552 unsigned DiagID = diag::err_missing_dependent_template_keyword; 553 if (getLangOpts().MicrosoftExt) 554 DiagID = diag::warn_missing_dependent_template_keyword; 555 556 Diag(Tok.getLocation(), DiagID) 557 << II.getName() 558 << FixItHint::CreateInsertion(Tok.getLocation(), "template "); 559 560 if (TemplateNameKind TNK 561 = Actions.ActOnDependentTemplateName(getCurScope(), 562 SS, SourceLocation(), 563 TemplateName, ObjectType, 564 EnteringContext, Template)) { 565 // Consume the identifier. 566 ConsumeToken(); 567 if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(), 568 TemplateName, false)) 569 return true; 570 } 571 else 572 return true; 573 574 continue; 575 } 576 } 577 578 // We don't have any tokens that form the beginning of a 579 // nested-name-specifier, so we're done. 580 break; 581 } 582 583 // Even if we didn't see any pieces of a nested-name-specifier, we 584 // still check whether there is a tilde in this position, which 585 // indicates a potential pseudo-destructor. 586 if (CheckForDestructor && Tok.is(tok::tilde)) 587 *MayBePseudoDestructor = true; 588 589 return false; 590 } 591 592 ExprResult Parser::tryParseCXXIdExpression(CXXScopeSpec &SS, bool isAddressOfOperand, 593 Token &Replacement) { 594 SourceLocation TemplateKWLoc; 595 UnqualifiedId Name; 596 if (ParseUnqualifiedId(SS, 597 /*EnteringContext=*/false, 598 /*AllowDestructorName=*/false, 599 /*AllowConstructorName=*/false, 600 /*ObjectType=*/ParsedType(), TemplateKWLoc, Name)) 601 return ExprError(); 602 603 // This is only the direct operand of an & operator if it is not 604 // followed by a postfix-expression suffix. 605 if (isAddressOfOperand && isPostfixExpressionSuffixStart()) 606 isAddressOfOperand = false; 607 608 return Actions.ActOnIdExpression(getCurScope(), SS, TemplateKWLoc, Name, 609 Tok.is(tok::l_paren), isAddressOfOperand, 610 nullptr, /*IsInlineAsmIdentifier=*/false, 611 &Replacement); 612 } 613 614 /// ParseCXXIdExpression - Handle id-expression. 615 /// 616 /// id-expression: 617 /// unqualified-id 618 /// qualified-id 619 /// 620 /// qualified-id: 621 /// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id 622 /// '::' identifier 623 /// '::' operator-function-id 624 /// '::' template-id 625 /// 626 /// NOTE: The standard specifies that, for qualified-id, the parser does not 627 /// expect: 628 /// 629 /// '::' conversion-function-id 630 /// '::' '~' class-name 631 /// 632 /// This may cause a slight inconsistency on diagnostics: 633 /// 634 /// class C {}; 635 /// namespace A {} 636 /// void f() { 637 /// :: A :: ~ C(); // Some Sema error about using destructor with a 638 /// // namespace. 639 /// :: ~ C(); // Some Parser error like 'unexpected ~'. 640 /// } 641 /// 642 /// We simplify the parser a bit and make it work like: 643 /// 644 /// qualified-id: 645 /// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id 646 /// '::' unqualified-id 647 /// 648 /// That way Sema can handle and report similar errors for namespaces and the 649 /// global scope. 650 /// 651 /// The isAddressOfOperand parameter indicates that this id-expression is a 652 /// direct operand of the address-of operator. This is, besides member contexts, 653 /// the only place where a qualified-id naming a non-static class member may 654 /// appear. 655 /// 656 ExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) { 657 // qualified-id: 658 // '::'[opt] nested-name-specifier 'template'[opt] unqualified-id 659 // '::' unqualified-id 660 // 661 CXXScopeSpec SS; 662 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), /*EnteringContext=*/false); 663 664 Token Replacement; 665 ExprResult Result = 666 tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement); 667 if (Result.isUnset()) { 668 // If the ExprResult is valid but null, then typo correction suggested a 669 // keyword replacement that needs to be reparsed. 670 UnconsumeToken(Replacement); 671 Result = tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement); 672 } 673 assert(!Result.isUnset() && "Typo correction suggested a keyword replacement " 674 "for a previous keyword suggestion"); 675 return Result; 676 } 677 678 /// ParseLambdaExpression - Parse a C++11 lambda expression. 679 /// 680 /// lambda-expression: 681 /// lambda-introducer lambda-declarator[opt] compound-statement 682 /// 683 /// lambda-introducer: 684 /// '[' lambda-capture[opt] ']' 685 /// 686 /// lambda-capture: 687 /// capture-default 688 /// capture-list 689 /// capture-default ',' capture-list 690 /// 691 /// capture-default: 692 /// '&' 693 /// '=' 694 /// 695 /// capture-list: 696 /// capture 697 /// capture-list ',' capture 698 /// 699 /// capture: 700 /// simple-capture 701 /// init-capture [C++1y] 702 /// 703 /// simple-capture: 704 /// identifier 705 /// '&' identifier 706 /// 'this' 707 /// 708 /// init-capture: [C++1y] 709 /// identifier initializer 710 /// '&' identifier initializer 711 /// 712 /// lambda-declarator: 713 /// '(' parameter-declaration-clause ')' attribute-specifier[opt] 714 /// 'mutable'[opt] exception-specification[opt] 715 /// trailing-return-type[opt] 716 /// 717 ExprResult Parser::ParseLambdaExpression() { 718 // Parse lambda-introducer. 719 LambdaIntroducer Intro; 720 Optional<unsigned> DiagID = ParseLambdaIntroducer(Intro); 721 if (DiagID) { 722 Diag(Tok, DiagID.getValue()); 723 SkipUntil(tok::r_square, StopAtSemi); 724 SkipUntil(tok::l_brace, StopAtSemi); 725 SkipUntil(tok::r_brace, StopAtSemi); 726 return ExprError(); 727 } 728 729 return ParseLambdaExpressionAfterIntroducer(Intro); 730 } 731 732 /// TryParseLambdaExpression - Use lookahead and potentially tentative 733 /// parsing to determine if we are looking at a C++0x lambda expression, and parse 734 /// it if we are. 735 /// 736 /// If we are not looking at a lambda expression, returns ExprError(). 737 ExprResult Parser::TryParseLambdaExpression() { 738 assert(getLangOpts().CPlusPlus11 739 && Tok.is(tok::l_square) 740 && "Not at the start of a possible lambda expression."); 741 742 const Token Next = NextToken(), After = GetLookAheadToken(2); 743 744 // If lookahead indicates this is a lambda... 745 if (Next.is(tok::r_square) || // [] 746 Next.is(tok::equal) || // [= 747 (Next.is(tok::amp) && // [&] or [&, 748 (After.is(tok::r_square) || 749 After.is(tok::comma))) || 750 (Next.is(tok::identifier) && // [identifier] 751 After.is(tok::r_square))) { 752 return ParseLambdaExpression(); 753 } 754 755 // If lookahead indicates an ObjC message send... 756 // [identifier identifier 757 if (Next.is(tok::identifier) && After.is(tok::identifier)) { 758 return ExprEmpty(); 759 } 760 761 // Here, we're stuck: lambda introducers and Objective-C message sends are 762 // unambiguous, but it requires arbitrary lookhead. [a,b,c,d,e,f,g] is a 763 // lambda, and [a,b,c,d,e,f,g h] is a Objective-C message send. Instead of 764 // writing two routines to parse a lambda introducer, just try to parse 765 // a lambda introducer first, and fall back if that fails. 766 // (TryParseLambdaIntroducer never produces any diagnostic output.) 767 LambdaIntroducer Intro; 768 if (TryParseLambdaIntroducer(Intro)) 769 return ExprEmpty(); 770 771 return ParseLambdaExpressionAfterIntroducer(Intro); 772 } 773 774 /// \brief Parse a lambda introducer. 775 /// \param Intro A LambdaIntroducer filled in with information about the 776 /// contents of the lambda-introducer. 777 /// \param SkippedInits If non-null, we are disambiguating between an Obj-C 778 /// message send and a lambda expression. In this mode, we will 779 /// sometimes skip the initializers for init-captures and not fully 780 /// populate \p Intro. This flag will be set to \c true if we do so. 781 /// \return A DiagnosticID if it hit something unexpected. The location for 782 /// for the diagnostic is that of the current token. 783 Optional<unsigned> Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro, 784 bool *SkippedInits) { 785 typedef Optional<unsigned> DiagResult; 786 787 assert(Tok.is(tok::l_square) && "Lambda expressions begin with '['."); 788 BalancedDelimiterTracker T(*this, tok::l_square); 789 T.consumeOpen(); 790 791 Intro.Range.setBegin(T.getOpenLocation()); 792 793 bool first = true; 794 795 // Parse capture-default. 796 if (Tok.is(tok::amp) && 797 (NextToken().is(tok::comma) || NextToken().is(tok::r_square))) { 798 Intro.Default = LCD_ByRef; 799 Intro.DefaultLoc = ConsumeToken(); 800 first = false; 801 } else if (Tok.is(tok::equal)) { 802 Intro.Default = LCD_ByCopy; 803 Intro.DefaultLoc = ConsumeToken(); 804 first = false; 805 } 806 807 while (Tok.isNot(tok::r_square)) { 808 if (!first) { 809 if (Tok.isNot(tok::comma)) { 810 // Provide a completion for a lambda introducer here. Except 811 // in Objective-C, where this is Almost Surely meant to be a message 812 // send. In that case, fail here and let the ObjC message 813 // expression parser perform the completion. 814 if (Tok.is(tok::code_completion) && 815 !(getLangOpts().ObjC1 && Intro.Default == LCD_None && 816 !Intro.Captures.empty())) { 817 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro, 818 /*AfterAmpersand=*/false); 819 cutOffParsing(); 820 break; 821 } 822 823 return DiagResult(diag::err_expected_comma_or_rsquare); 824 } 825 ConsumeToken(); 826 } 827 828 if (Tok.is(tok::code_completion)) { 829 // If we're in Objective-C++ and we have a bare '[', then this is more 830 // likely to be a message receiver. 831 if (getLangOpts().ObjC1 && first) 832 Actions.CodeCompleteObjCMessageReceiver(getCurScope()); 833 else 834 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro, 835 /*AfterAmpersand=*/false); 836 cutOffParsing(); 837 break; 838 } 839 840 first = false; 841 842 // Parse capture. 843 LambdaCaptureKind Kind = LCK_ByCopy; 844 SourceLocation Loc; 845 IdentifierInfo *Id = nullptr; 846 SourceLocation EllipsisLoc; 847 ExprResult Init; 848 849 if (Tok.is(tok::kw_this)) { 850 Kind = LCK_This; 851 Loc = ConsumeToken(); 852 } else { 853 if (Tok.is(tok::amp)) { 854 Kind = LCK_ByRef; 855 ConsumeToken(); 856 857 if (Tok.is(tok::code_completion)) { 858 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro, 859 /*AfterAmpersand=*/true); 860 cutOffParsing(); 861 break; 862 } 863 } 864 865 if (Tok.is(tok::identifier)) { 866 Id = Tok.getIdentifierInfo(); 867 Loc = ConsumeToken(); 868 } else if (Tok.is(tok::kw_this)) { 869 // FIXME: If we want to suggest a fixit here, will need to return more 870 // than just DiagnosticID. Perhaps full DiagnosticBuilder that can be 871 // Clear()ed to prevent emission in case of tentative parsing? 872 return DiagResult(diag::err_this_captured_by_reference); 873 } else { 874 return DiagResult(diag::err_expected_capture); 875 } 876 877 if (Tok.is(tok::l_paren)) { 878 BalancedDelimiterTracker Parens(*this, tok::l_paren); 879 Parens.consumeOpen(); 880 881 ExprVector Exprs; 882 CommaLocsTy Commas; 883 if (SkippedInits) { 884 Parens.skipToEnd(); 885 *SkippedInits = true; 886 } else if (ParseExpressionList(Exprs, Commas)) { 887 Parens.skipToEnd(); 888 Init = ExprError(); 889 } else { 890 Parens.consumeClose(); 891 Init = Actions.ActOnParenListExpr(Parens.getOpenLocation(), 892 Parens.getCloseLocation(), 893 Exprs); 894 } 895 } else if (Tok.is(tok::l_brace) || Tok.is(tok::equal)) { 896 // Each lambda init-capture forms its own full expression, which clears 897 // Actions.MaybeODRUseExprs. So create an expression evaluation context 898 // to save the necessary state, and restore it later. 899 EnterExpressionEvaluationContext EC(Actions, 900 Sema::PotentiallyEvaluated); 901 bool HadEquals = TryConsumeToken(tok::equal); 902 903 if (!SkippedInits) { 904 // Warn on constructs that will change meaning when we implement N3922 905 if (!HadEquals && Tok.is(tok::l_brace)) { 906 Diag(Tok, diag::warn_init_capture_direct_list_init) 907 << FixItHint::CreateInsertion(Tok.getLocation(), "="); 908 } 909 Init = ParseInitializer(); 910 } else if (Tok.is(tok::l_brace)) { 911 BalancedDelimiterTracker Braces(*this, tok::l_brace); 912 Braces.consumeOpen(); 913 Braces.skipToEnd(); 914 *SkippedInits = true; 915 } else { 916 // We're disambiguating this: 917 // 918 // [..., x = expr 919 // 920 // We need to find the end of the following expression in order to 921 // determine whether this is an Obj-C message send's receiver, a 922 // C99 designator, or a lambda init-capture. 923 // 924 // Parse the expression to find where it ends, and annotate it back 925 // onto the tokens. We would have parsed this expression the same way 926 // in either case: both the RHS of an init-capture and the RHS of an 927 // assignment expression are parsed as an initializer-clause, and in 928 // neither case can anything be added to the scope between the '[' and 929 // here. 930 // 931 // FIXME: This is horrible. Adding a mechanism to skip an expression 932 // would be much cleaner. 933 // FIXME: If there is a ',' before the next ']' or ':', we can skip to 934 // that instead. (And if we see a ':' with no matching '?', we can 935 // classify this as an Obj-C message send.) 936 SourceLocation StartLoc = Tok.getLocation(); 937 InMessageExpressionRAIIObject MaybeInMessageExpression(*this, true); 938 Init = ParseInitializer(); 939 940 if (Tok.getLocation() != StartLoc) { 941 // Back out the lexing of the token after the initializer. 942 PP.RevertCachedTokens(1); 943 944 // Replace the consumed tokens with an appropriate annotation. 945 Tok.setLocation(StartLoc); 946 Tok.setKind(tok::annot_primary_expr); 947 setExprAnnotation(Tok, Init); 948 Tok.setAnnotationEndLoc(PP.getLastCachedTokenLocation()); 949 PP.AnnotateCachedTokens(Tok); 950 951 // Consume the annotated initializer. 952 ConsumeToken(); 953 } 954 } 955 } else 956 TryConsumeToken(tok::ellipsis, EllipsisLoc); 957 } 958 // If this is an init capture, process the initialization expression 959 // right away. For lambda init-captures such as the following: 960 // const int x = 10; 961 // auto L = [i = x+1](int a) { 962 // return [j = x+2, 963 // &k = x](char b) { }; 964 // }; 965 // keep in mind that each lambda init-capture has to have: 966 // - its initialization expression executed in the context 967 // of the enclosing/parent decl-context. 968 // - but the variable itself has to be 'injected' into the 969 // decl-context of its lambda's call-operator (which has 970 // not yet been created). 971 // Each init-expression is a full-expression that has to get 972 // Sema-analyzed (for capturing etc.) before its lambda's 973 // call-operator's decl-context, scope & scopeinfo are pushed on their 974 // respective stacks. Thus if any variable is odr-used in the init-capture 975 // it will correctly get captured in the enclosing lambda, if one exists. 976 // The init-variables above are created later once the lambdascope and 977 // call-operators decl-context is pushed onto its respective stack. 978 979 // Since the lambda init-capture's initializer expression occurs in the 980 // context of the enclosing function or lambda, therefore we can not wait 981 // till a lambda scope has been pushed on before deciding whether the 982 // variable needs to be captured. We also need to process all 983 // lvalue-to-rvalue conversions and discarded-value conversions, 984 // so that we can avoid capturing certain constant variables. 985 // For e.g., 986 // void test() { 987 // const int x = 10; 988 // auto L = [&z = x](char a) { <-- don't capture by the current lambda 989 // return [y = x](int i) { <-- don't capture by enclosing lambda 990 // return y; 991 // } 992 // }; 993 // If x was not const, the second use would require 'L' to capture, and 994 // that would be an error. 995 996 ParsedType InitCaptureParsedType; 997 if (Init.isUsable()) { 998 // Get the pointer and store it in an lvalue, so we can use it as an 999 // out argument. 1000 Expr *InitExpr = Init.get(); 1001 // This performs any lvalue-to-rvalue conversions if necessary, which 1002 // can affect what gets captured in the containing decl-context. 1003 QualType InitCaptureType = Actions.performLambdaInitCaptureInitialization( 1004 Loc, Kind == LCK_ByRef, Id, InitExpr); 1005 Init = InitExpr; 1006 InitCaptureParsedType.set(InitCaptureType); 1007 } 1008 Intro.addCapture(Kind, Loc, Id, EllipsisLoc, Init, InitCaptureParsedType); 1009 } 1010 1011 T.consumeClose(); 1012 Intro.Range.setEnd(T.getCloseLocation()); 1013 return DiagResult(); 1014 } 1015 1016 /// TryParseLambdaIntroducer - Tentatively parse a lambda introducer. 1017 /// 1018 /// Returns true if it hit something unexpected. 1019 bool Parser::TryParseLambdaIntroducer(LambdaIntroducer &Intro) { 1020 TentativeParsingAction PA(*this); 1021 1022 bool SkippedInits = false; 1023 Optional<unsigned> DiagID(ParseLambdaIntroducer(Intro, &SkippedInits)); 1024 1025 if (DiagID) { 1026 PA.Revert(); 1027 return true; 1028 } 1029 1030 if (SkippedInits) { 1031 // Parse it again, but this time parse the init-captures too. 1032 PA.Revert(); 1033 Intro = LambdaIntroducer(); 1034 DiagID = ParseLambdaIntroducer(Intro); 1035 assert(!DiagID && "parsing lambda-introducer failed on reparse"); 1036 return false; 1037 } 1038 1039 PA.Commit(); 1040 return false; 1041 } 1042 1043 /// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda 1044 /// expression. 1045 ExprResult Parser::ParseLambdaExpressionAfterIntroducer( 1046 LambdaIntroducer &Intro) { 1047 SourceLocation LambdaBeginLoc = Intro.Range.getBegin(); 1048 Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda); 1049 1050 PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc, 1051 "lambda expression parsing"); 1052 1053 1054 1055 // FIXME: Call into Actions to add any init-capture declarations to the 1056 // scope while parsing the lambda-declarator and compound-statement. 1057 1058 // Parse lambda-declarator[opt]. 1059 DeclSpec DS(AttrFactory); 1060 Declarator D(DS, Declarator::LambdaExprContext); 1061 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth); 1062 Actions.PushLambdaScope(); 1063 1064 TypeResult TrailingReturnType; 1065 if (Tok.is(tok::l_paren)) { 1066 ParseScope PrototypeScope(this, 1067 Scope::FunctionPrototypeScope | 1068 Scope::FunctionDeclarationScope | 1069 Scope::DeclScope); 1070 1071 SourceLocation DeclEndLoc; 1072 BalancedDelimiterTracker T(*this, tok::l_paren); 1073 T.consumeOpen(); 1074 SourceLocation LParenLoc = T.getOpenLocation(); 1075 1076 // Parse parameter-declaration-clause. 1077 ParsedAttributes Attr(AttrFactory); 1078 SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo; 1079 SourceLocation EllipsisLoc; 1080 1081 if (Tok.isNot(tok::r_paren)) { 1082 Actions.RecordParsingTemplateParameterDepth(TemplateParameterDepth); 1083 ParseParameterDeclarationClause(D, Attr, ParamInfo, EllipsisLoc); 1084 // For a generic lambda, each 'auto' within the parameter declaration 1085 // clause creates a template type parameter, so increment the depth. 1086 if (Actions.getCurGenericLambda()) 1087 ++CurTemplateDepthTracker; 1088 } 1089 T.consumeClose(); 1090 SourceLocation RParenLoc = T.getCloseLocation(); 1091 DeclEndLoc = RParenLoc; 1092 1093 // GNU-style attributes must be parsed before the mutable specifier to be 1094 // compatible with GCC. 1095 MaybeParseGNUAttributes(Attr, &DeclEndLoc); 1096 1097 // MSVC-style attributes must be parsed before the mutable specifier to be 1098 // compatible with MSVC. 1099 while (Tok.is(tok::kw___declspec)) 1100 ParseMicrosoftDeclSpec(Attr); 1101 1102 // Parse 'mutable'[opt]. 1103 SourceLocation MutableLoc; 1104 if (TryConsumeToken(tok::kw_mutable, MutableLoc)) 1105 DeclEndLoc = MutableLoc; 1106 1107 // Parse exception-specification[opt]. 1108 ExceptionSpecificationType ESpecType = EST_None; 1109 SourceRange ESpecRange; 1110 SmallVector<ParsedType, 2> DynamicExceptions; 1111 SmallVector<SourceRange, 2> DynamicExceptionRanges; 1112 ExprResult NoexceptExpr; 1113 CachedTokens *ExceptionSpecTokens; 1114 ESpecType = tryParseExceptionSpecification(/*Delayed=*/false, 1115 ESpecRange, 1116 DynamicExceptions, 1117 DynamicExceptionRanges, 1118 NoexceptExpr, 1119 ExceptionSpecTokens); 1120 1121 if (ESpecType != EST_None) 1122 DeclEndLoc = ESpecRange.getEnd(); 1123 1124 // Parse attribute-specifier[opt]. 1125 MaybeParseCXX11Attributes(Attr, &DeclEndLoc); 1126 1127 SourceLocation FunLocalRangeEnd = DeclEndLoc; 1128 1129 // Parse trailing-return-type[opt]. 1130 if (Tok.is(tok::arrow)) { 1131 FunLocalRangeEnd = Tok.getLocation(); 1132 SourceRange Range; 1133 TrailingReturnType = ParseTrailingReturnType(Range); 1134 if (Range.getEnd().isValid()) 1135 DeclEndLoc = Range.getEnd(); 1136 } 1137 1138 PrototypeScope.Exit(); 1139 1140 SourceLocation NoLoc; 1141 D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true, 1142 /*isAmbiguous=*/false, 1143 LParenLoc, 1144 ParamInfo.data(), ParamInfo.size(), 1145 EllipsisLoc, RParenLoc, 1146 DS.getTypeQualifiers(), 1147 /*RefQualifierIsLValueRef=*/true, 1148 /*RefQualifierLoc=*/NoLoc, 1149 /*ConstQualifierLoc=*/NoLoc, 1150 /*VolatileQualifierLoc=*/NoLoc, 1151 /*RestrictQualifierLoc=*/NoLoc, 1152 MutableLoc, 1153 ESpecType, ESpecRange.getBegin(), 1154 DynamicExceptions.data(), 1155 DynamicExceptionRanges.data(), 1156 DynamicExceptions.size(), 1157 NoexceptExpr.isUsable() ? 1158 NoexceptExpr.get() : nullptr, 1159 /*ExceptionSpecTokens*/nullptr, 1160 LParenLoc, FunLocalRangeEnd, D, 1161 TrailingReturnType), 1162 Attr, DeclEndLoc); 1163 } else if (Tok.is(tok::kw_mutable) || Tok.is(tok::arrow) || 1164 Tok.is(tok::kw___attribute) || 1165 (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) { 1166 // It's common to forget that one needs '()' before 'mutable', an attribute 1167 // specifier, or the result type. Deal with this. 1168 unsigned TokKind = 0; 1169 switch (Tok.getKind()) { 1170 case tok::kw_mutable: TokKind = 0; break; 1171 case tok::arrow: TokKind = 1; break; 1172 case tok::kw___attribute: 1173 case tok::l_square: TokKind = 2; break; 1174 default: llvm_unreachable("Unknown token kind"); 1175 } 1176 1177 Diag(Tok, diag::err_lambda_missing_parens) 1178 << TokKind 1179 << FixItHint::CreateInsertion(Tok.getLocation(), "() "); 1180 SourceLocation DeclLoc = Tok.getLocation(); 1181 SourceLocation DeclEndLoc = DeclLoc; 1182 1183 // GNU-style attributes must be parsed before the mutable specifier to be 1184 // compatible with GCC. 1185 ParsedAttributes Attr(AttrFactory); 1186 MaybeParseGNUAttributes(Attr, &DeclEndLoc); 1187 1188 // Parse 'mutable', if it's there. 1189 SourceLocation MutableLoc; 1190 if (Tok.is(tok::kw_mutable)) { 1191 MutableLoc = ConsumeToken(); 1192 DeclEndLoc = MutableLoc; 1193 } 1194 1195 // Parse attribute-specifier[opt]. 1196 MaybeParseCXX11Attributes(Attr, &DeclEndLoc); 1197 1198 // Parse the return type, if there is one. 1199 if (Tok.is(tok::arrow)) { 1200 SourceRange Range; 1201 TrailingReturnType = ParseTrailingReturnType(Range); 1202 if (Range.getEnd().isValid()) 1203 DeclEndLoc = Range.getEnd(); 1204 } 1205 1206 SourceLocation NoLoc; 1207 D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true, 1208 /*isAmbiguous=*/false, 1209 /*LParenLoc=*/NoLoc, 1210 /*Params=*/nullptr, 1211 /*NumParams=*/0, 1212 /*EllipsisLoc=*/NoLoc, 1213 /*RParenLoc=*/NoLoc, 1214 /*TypeQuals=*/0, 1215 /*RefQualifierIsLValueRef=*/true, 1216 /*RefQualifierLoc=*/NoLoc, 1217 /*ConstQualifierLoc=*/NoLoc, 1218 /*VolatileQualifierLoc=*/NoLoc, 1219 /*RestrictQualifierLoc=*/NoLoc, 1220 MutableLoc, 1221 EST_None, 1222 /*ESpecLoc=*/NoLoc, 1223 /*Exceptions=*/nullptr, 1224 /*ExceptionRanges=*/nullptr, 1225 /*NumExceptions=*/0, 1226 /*NoexceptExpr=*/nullptr, 1227 /*ExceptionSpecTokens=*/nullptr, 1228 DeclLoc, DeclEndLoc, D, 1229 TrailingReturnType), 1230 Attr, DeclEndLoc); 1231 } 1232 1233 1234 // FIXME: Rename BlockScope -> ClosureScope if we decide to continue using 1235 // it. 1236 unsigned ScopeFlags = Scope::BlockScope | Scope::FnScope | Scope::DeclScope; 1237 ParseScope BodyScope(this, ScopeFlags); 1238 1239 Actions.ActOnStartOfLambdaDefinition(Intro, D, getCurScope()); 1240 1241 // Parse compound-statement. 1242 if (!Tok.is(tok::l_brace)) { 1243 Diag(Tok, diag::err_expected_lambda_body); 1244 Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope()); 1245 return ExprError(); 1246 } 1247 1248 StmtResult Stmt(ParseCompoundStatementBody()); 1249 BodyScope.Exit(); 1250 1251 if (!Stmt.isInvalid() && !TrailingReturnType.isInvalid()) 1252 return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.get(), getCurScope()); 1253 1254 Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope()); 1255 return ExprError(); 1256 } 1257 1258 /// ParseCXXCasts - This handles the various ways to cast expressions to another 1259 /// type. 1260 /// 1261 /// postfix-expression: [C++ 5.2p1] 1262 /// 'dynamic_cast' '<' type-name '>' '(' expression ')' 1263 /// 'static_cast' '<' type-name '>' '(' expression ')' 1264 /// 'reinterpret_cast' '<' type-name '>' '(' expression ')' 1265 /// 'const_cast' '<' type-name '>' '(' expression ')' 1266 /// 1267 ExprResult Parser::ParseCXXCasts() { 1268 tok::TokenKind Kind = Tok.getKind(); 1269 const char *CastName = nullptr; // For error messages 1270 1271 switch (Kind) { 1272 default: llvm_unreachable("Unknown C++ cast!"); 1273 case tok::kw_const_cast: CastName = "const_cast"; break; 1274 case tok::kw_dynamic_cast: CastName = "dynamic_cast"; break; 1275 case tok::kw_reinterpret_cast: CastName = "reinterpret_cast"; break; 1276 case tok::kw_static_cast: CastName = "static_cast"; break; 1277 } 1278 1279 SourceLocation OpLoc = ConsumeToken(); 1280 SourceLocation LAngleBracketLoc = Tok.getLocation(); 1281 1282 // Check for "<::" which is parsed as "[:". If found, fix token stream, 1283 // diagnose error, suggest fix, and recover parsing. 1284 if (Tok.is(tok::l_square) && Tok.getLength() == 2) { 1285 Token Next = NextToken(); 1286 if (Next.is(tok::colon) && areTokensAdjacent(Tok, Next)) 1287 FixDigraph(*this, PP, Tok, Next, Kind, /*AtDigraph*/true); 1288 } 1289 1290 if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName)) 1291 return ExprError(); 1292 1293 // Parse the common declaration-specifiers piece. 1294 DeclSpec DS(AttrFactory); 1295 ParseSpecifierQualifierList(DS); 1296 1297 // Parse the abstract-declarator, if present. 1298 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext); 1299 ParseDeclarator(DeclaratorInfo); 1300 1301 SourceLocation RAngleBracketLoc = Tok.getLocation(); 1302 1303 if (ExpectAndConsume(tok::greater)) 1304 return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << tok::less); 1305 1306 SourceLocation LParenLoc, RParenLoc; 1307 BalancedDelimiterTracker T(*this, tok::l_paren); 1308 1309 if (T.expectAndConsume(diag::err_expected_lparen_after, CastName)) 1310 return ExprError(); 1311 1312 ExprResult Result = ParseExpression(); 1313 1314 // Match the ')'. 1315 T.consumeClose(); 1316 1317 if (!Result.isInvalid() && !DeclaratorInfo.isInvalidType()) 1318 Result = Actions.ActOnCXXNamedCast(OpLoc, Kind, 1319 LAngleBracketLoc, DeclaratorInfo, 1320 RAngleBracketLoc, 1321 T.getOpenLocation(), Result.get(), 1322 T.getCloseLocation()); 1323 1324 return Result; 1325 } 1326 1327 /// ParseCXXTypeid - This handles the C++ typeid expression. 1328 /// 1329 /// postfix-expression: [C++ 5.2p1] 1330 /// 'typeid' '(' expression ')' 1331 /// 'typeid' '(' type-id ')' 1332 /// 1333 ExprResult Parser::ParseCXXTypeid() { 1334 assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!"); 1335 1336 SourceLocation OpLoc = ConsumeToken(); 1337 SourceLocation LParenLoc, RParenLoc; 1338 BalancedDelimiterTracker T(*this, tok::l_paren); 1339 1340 // typeid expressions are always parenthesized. 1341 if (T.expectAndConsume(diag::err_expected_lparen_after, "typeid")) 1342 return ExprError(); 1343 LParenLoc = T.getOpenLocation(); 1344 1345 ExprResult Result; 1346 1347 // C++0x [expr.typeid]p3: 1348 // When typeid is applied to an expression other than an lvalue of a 1349 // polymorphic class type [...] The expression is an unevaluated 1350 // operand (Clause 5). 1351 // 1352 // Note that we can't tell whether the expression is an lvalue of a 1353 // polymorphic class type until after we've parsed the expression; we 1354 // speculatively assume the subexpression is unevaluated, and fix it up 1355 // later. 1356 // 1357 // We enter the unevaluated context before trying to determine whether we 1358 // have a type-id, because the tentative parse logic will try to resolve 1359 // names, and must treat them as unevaluated. 1360 EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated, 1361 Sema::ReuseLambdaContextDecl); 1362 1363 if (isTypeIdInParens()) { 1364 TypeResult Ty = ParseTypeName(); 1365 1366 // Match the ')'. 1367 T.consumeClose(); 1368 RParenLoc = T.getCloseLocation(); 1369 if (Ty.isInvalid() || RParenLoc.isInvalid()) 1370 return ExprError(); 1371 1372 Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/true, 1373 Ty.get().getAsOpaquePtr(), RParenLoc); 1374 } else { 1375 Result = ParseExpression(); 1376 1377 // Match the ')'. 1378 if (Result.isInvalid()) 1379 SkipUntil(tok::r_paren, StopAtSemi); 1380 else { 1381 T.consumeClose(); 1382 RParenLoc = T.getCloseLocation(); 1383 if (RParenLoc.isInvalid()) 1384 return ExprError(); 1385 1386 Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/false, 1387 Result.get(), RParenLoc); 1388 } 1389 } 1390 1391 return Result; 1392 } 1393 1394 /// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression. 1395 /// 1396 /// '__uuidof' '(' expression ')' 1397 /// '__uuidof' '(' type-id ')' 1398 /// 1399 ExprResult Parser::ParseCXXUuidof() { 1400 assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!"); 1401 1402 SourceLocation OpLoc = ConsumeToken(); 1403 BalancedDelimiterTracker T(*this, tok::l_paren); 1404 1405 // __uuidof expressions are always parenthesized. 1406 if (T.expectAndConsume(diag::err_expected_lparen_after, "__uuidof")) 1407 return ExprError(); 1408 1409 ExprResult Result; 1410 1411 if (isTypeIdInParens()) { 1412 TypeResult Ty = ParseTypeName(); 1413 1414 // Match the ')'. 1415 T.consumeClose(); 1416 1417 if (Ty.isInvalid()) 1418 return ExprError(); 1419 1420 Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(), /*isType=*/true, 1421 Ty.get().getAsOpaquePtr(), 1422 T.getCloseLocation()); 1423 } else { 1424 EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated); 1425 Result = ParseExpression(); 1426 1427 // Match the ')'. 1428 if (Result.isInvalid()) 1429 SkipUntil(tok::r_paren, StopAtSemi); 1430 else { 1431 T.consumeClose(); 1432 1433 Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(), 1434 /*isType=*/false, 1435 Result.get(), T.getCloseLocation()); 1436 } 1437 } 1438 1439 return Result; 1440 } 1441 1442 /// \brief Parse a C++ pseudo-destructor expression after the base, 1443 /// . or -> operator, and nested-name-specifier have already been 1444 /// parsed. 1445 /// 1446 /// postfix-expression: [C++ 5.2] 1447 /// postfix-expression . pseudo-destructor-name 1448 /// postfix-expression -> pseudo-destructor-name 1449 /// 1450 /// pseudo-destructor-name: 1451 /// ::[opt] nested-name-specifier[opt] type-name :: ~type-name 1452 /// ::[opt] nested-name-specifier template simple-template-id :: 1453 /// ~type-name 1454 /// ::[opt] nested-name-specifier[opt] ~type-name 1455 /// 1456 ExprResult 1457 Parser::ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc, 1458 tok::TokenKind OpKind, 1459 CXXScopeSpec &SS, 1460 ParsedType ObjectType) { 1461 // We're parsing either a pseudo-destructor-name or a dependent 1462 // member access that has the same form as a 1463 // pseudo-destructor-name. We parse both in the same way and let 1464 // the action model sort them out. 1465 // 1466 // Note that the ::[opt] nested-name-specifier[opt] has already 1467 // been parsed, and if there was a simple-template-id, it has 1468 // been coalesced into a template-id annotation token. 1469 UnqualifiedId FirstTypeName; 1470 SourceLocation CCLoc; 1471 if (Tok.is(tok::identifier)) { 1472 FirstTypeName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation()); 1473 ConsumeToken(); 1474 assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail"); 1475 CCLoc = ConsumeToken(); 1476 } else if (Tok.is(tok::annot_template_id)) { 1477 // FIXME: retrieve TemplateKWLoc from template-id annotation and 1478 // store it in the pseudo-dtor node (to be used when instantiating it). 1479 FirstTypeName.setTemplateId( 1480 (TemplateIdAnnotation *)Tok.getAnnotationValue()); 1481 ConsumeToken(); 1482 assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail"); 1483 CCLoc = ConsumeToken(); 1484 } else { 1485 FirstTypeName.setIdentifier(nullptr, SourceLocation()); 1486 } 1487 1488 // Parse the tilde. 1489 assert(Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail"); 1490 SourceLocation TildeLoc = ConsumeToken(); 1491 1492 if (Tok.is(tok::kw_decltype) && !FirstTypeName.isValid() && SS.isEmpty()) { 1493 DeclSpec DS(AttrFactory); 1494 ParseDecltypeSpecifier(DS); 1495 if (DS.getTypeSpecType() == TST_error) 1496 return ExprError(); 1497 return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind, 1498 TildeLoc, DS); 1499 } 1500 1501 if (!Tok.is(tok::identifier)) { 1502 Diag(Tok, diag::err_destructor_tilde_identifier); 1503 return ExprError(); 1504 } 1505 1506 // Parse the second type. 1507 UnqualifiedId SecondTypeName; 1508 IdentifierInfo *Name = Tok.getIdentifierInfo(); 1509 SourceLocation NameLoc = ConsumeToken(); 1510 SecondTypeName.setIdentifier(Name, NameLoc); 1511 1512 // If there is a '<', the second type name is a template-id. Parse 1513 // it as such. 1514 if (Tok.is(tok::less) && 1515 ParseUnqualifiedIdTemplateId(SS, SourceLocation(), 1516 Name, NameLoc, 1517 false, ObjectType, SecondTypeName, 1518 /*AssumeTemplateName=*/true)) 1519 return ExprError(); 1520 1521 return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind, 1522 SS, FirstTypeName, CCLoc, TildeLoc, 1523 SecondTypeName); 1524 } 1525 1526 /// ParseCXXBoolLiteral - This handles the C++ Boolean literals. 1527 /// 1528 /// boolean-literal: [C++ 2.13.5] 1529 /// 'true' 1530 /// 'false' 1531 ExprResult Parser::ParseCXXBoolLiteral() { 1532 tok::TokenKind Kind = Tok.getKind(); 1533 return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind); 1534 } 1535 1536 /// ParseThrowExpression - This handles the C++ throw expression. 1537 /// 1538 /// throw-expression: [C++ 15] 1539 /// 'throw' assignment-expression[opt] 1540 ExprResult Parser::ParseThrowExpression() { 1541 assert(Tok.is(tok::kw_throw) && "Not throw!"); 1542 SourceLocation ThrowLoc = ConsumeToken(); // Eat the throw token. 1543 1544 // If the current token isn't the start of an assignment-expression, 1545 // then the expression is not present. This handles things like: 1546 // "C ? throw : (void)42", which is crazy but legal. 1547 switch (Tok.getKind()) { // FIXME: move this predicate somewhere common. 1548 case tok::semi: 1549 case tok::r_paren: 1550 case tok::r_square: 1551 case tok::r_brace: 1552 case tok::colon: 1553 case tok::comma: 1554 return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, nullptr); 1555 1556 default: 1557 ExprResult Expr(ParseAssignmentExpression()); 1558 if (Expr.isInvalid()) return Expr; 1559 return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, Expr.get()); 1560 } 1561 } 1562 1563 /// ParseCXXThis - This handles the C++ 'this' pointer. 1564 /// 1565 /// C++ 9.3.2: In the body of a non-static member function, the keyword this is 1566 /// a non-lvalue expression whose value is the address of the object for which 1567 /// the function is called. 1568 ExprResult Parser::ParseCXXThis() { 1569 assert(Tok.is(tok::kw_this) && "Not 'this'!"); 1570 SourceLocation ThisLoc = ConsumeToken(); 1571 return Actions.ActOnCXXThis(ThisLoc); 1572 } 1573 1574 /// ParseCXXTypeConstructExpression - Parse construction of a specified type. 1575 /// Can be interpreted either as function-style casting ("int(x)") 1576 /// or class type construction ("ClassType(x,y,z)") 1577 /// or creation of a value-initialized type ("int()"). 1578 /// See [C++ 5.2.3]. 1579 /// 1580 /// postfix-expression: [C++ 5.2p1] 1581 /// simple-type-specifier '(' expression-list[opt] ')' 1582 /// [C++0x] simple-type-specifier braced-init-list 1583 /// typename-specifier '(' expression-list[opt] ')' 1584 /// [C++0x] typename-specifier braced-init-list 1585 /// 1586 ExprResult 1587 Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) { 1588 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext); 1589 ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get(); 1590 1591 assert((Tok.is(tok::l_paren) || 1592 (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))) 1593 && "Expected '(' or '{'!"); 1594 1595 if (Tok.is(tok::l_brace)) { 1596 ExprResult Init = ParseBraceInitializer(); 1597 if (Init.isInvalid()) 1598 return Init; 1599 Expr *InitList = Init.get(); 1600 return Actions.ActOnCXXTypeConstructExpr(TypeRep, SourceLocation(), 1601 MultiExprArg(&InitList, 1), 1602 SourceLocation()); 1603 } else { 1604 BalancedDelimiterTracker T(*this, tok::l_paren); 1605 T.consumeOpen(); 1606 1607 ExprVector Exprs; 1608 CommaLocsTy CommaLocs; 1609 1610 if (Tok.isNot(tok::r_paren)) { 1611 if (ParseExpressionList(Exprs, CommaLocs, [&] { 1612 Actions.CodeCompleteConstructor(getCurScope(), 1613 TypeRep.get()->getCanonicalTypeInternal(), 1614 DS.getLocEnd(), Exprs); 1615 })) { 1616 SkipUntil(tok::r_paren, StopAtSemi); 1617 return ExprError(); 1618 } 1619 } 1620 1621 // Match the ')'. 1622 T.consumeClose(); 1623 1624 // TypeRep could be null, if it references an invalid typedef. 1625 if (!TypeRep) 1626 return ExprError(); 1627 1628 assert((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&& 1629 "Unexpected number of commas!"); 1630 return Actions.ActOnCXXTypeConstructExpr(TypeRep, T.getOpenLocation(), 1631 Exprs, 1632 T.getCloseLocation()); 1633 } 1634 } 1635 1636 /// ParseCXXCondition - if/switch/while condition expression. 1637 /// 1638 /// condition: 1639 /// expression 1640 /// type-specifier-seq declarator '=' assignment-expression 1641 /// [C++11] type-specifier-seq declarator '=' initializer-clause 1642 /// [C++11] type-specifier-seq declarator braced-init-list 1643 /// [GNU] type-specifier-seq declarator simple-asm-expr[opt] attributes[opt] 1644 /// '=' assignment-expression 1645 /// 1646 /// \param ExprOut if the condition was parsed as an expression, the parsed 1647 /// expression. 1648 /// 1649 /// \param DeclOut if the condition was parsed as a declaration, the parsed 1650 /// declaration. 1651 /// 1652 /// \param Loc The location of the start of the statement that requires this 1653 /// condition, e.g., the "for" in a for loop. 1654 /// 1655 /// \param ConvertToBoolean Whether the condition expression should be 1656 /// converted to a boolean value. 1657 /// 1658 /// \returns true if there was a parsing, false otherwise. 1659 bool Parser::ParseCXXCondition(ExprResult &ExprOut, 1660 Decl *&DeclOut, 1661 SourceLocation Loc, 1662 bool ConvertToBoolean) { 1663 if (Tok.is(tok::code_completion)) { 1664 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition); 1665 cutOffParsing(); 1666 return true; 1667 } 1668 1669 ParsedAttributesWithRange attrs(AttrFactory); 1670 MaybeParseCXX11Attributes(attrs); 1671 1672 if (!isCXXConditionDeclaration()) { 1673 ProhibitAttributes(attrs); 1674 1675 // Parse the expression. 1676 ExprOut = ParseExpression(); // expression 1677 DeclOut = nullptr; 1678 if (ExprOut.isInvalid()) 1679 return true; 1680 1681 // If required, convert to a boolean value. 1682 if (ConvertToBoolean) 1683 ExprOut 1684 = Actions.ActOnBooleanCondition(getCurScope(), Loc, ExprOut.get()); 1685 return ExprOut.isInvalid(); 1686 } 1687 1688 // type-specifier-seq 1689 DeclSpec DS(AttrFactory); 1690 DS.takeAttributesFrom(attrs); 1691 ParseSpecifierQualifierList(DS); 1692 1693 // declarator 1694 Declarator DeclaratorInfo(DS, Declarator::ConditionContext); 1695 ParseDeclarator(DeclaratorInfo); 1696 1697 // simple-asm-expr[opt] 1698 if (Tok.is(tok::kw_asm)) { 1699 SourceLocation Loc; 1700 ExprResult AsmLabel(ParseSimpleAsm(&Loc)); 1701 if (AsmLabel.isInvalid()) { 1702 SkipUntil(tok::semi, StopAtSemi); 1703 return true; 1704 } 1705 DeclaratorInfo.setAsmLabel(AsmLabel.get()); 1706 DeclaratorInfo.SetRangeEnd(Loc); 1707 } 1708 1709 // If attributes are present, parse them. 1710 MaybeParseGNUAttributes(DeclaratorInfo); 1711 1712 // Type-check the declaration itself. 1713 DeclResult Dcl = Actions.ActOnCXXConditionDeclaration(getCurScope(), 1714 DeclaratorInfo); 1715 DeclOut = Dcl.get(); 1716 ExprOut = ExprError(); 1717 1718 // '=' assignment-expression 1719 // If a '==' or '+=' is found, suggest a fixit to '='. 1720 bool CopyInitialization = isTokenEqualOrEqualTypo(); 1721 if (CopyInitialization) 1722 ConsumeToken(); 1723 1724 ExprResult InitExpr = ExprError(); 1725 if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) { 1726 Diag(Tok.getLocation(), 1727 diag::warn_cxx98_compat_generalized_initializer_lists); 1728 InitExpr = ParseBraceInitializer(); 1729 } else if (CopyInitialization) { 1730 InitExpr = ParseAssignmentExpression(); 1731 } else if (Tok.is(tok::l_paren)) { 1732 // This was probably an attempt to initialize the variable. 1733 SourceLocation LParen = ConsumeParen(), RParen = LParen; 1734 if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch)) 1735 RParen = ConsumeParen(); 1736 Diag(DeclOut ? DeclOut->getLocation() : LParen, 1737 diag::err_expected_init_in_condition_lparen) 1738 << SourceRange(LParen, RParen); 1739 } else { 1740 Diag(DeclOut ? DeclOut->getLocation() : Tok.getLocation(), 1741 diag::err_expected_init_in_condition); 1742 } 1743 1744 if (!InitExpr.isInvalid()) 1745 Actions.AddInitializerToDecl(DeclOut, InitExpr.get(), !CopyInitialization, 1746 DS.containsPlaceholderType()); 1747 else 1748 Actions.ActOnInitializerError(DeclOut); 1749 1750 // FIXME: Build a reference to this declaration? Convert it to bool? 1751 // (This is currently handled by Sema). 1752 1753 Actions.FinalizeDeclaration(DeclOut); 1754 1755 return false; 1756 } 1757 1758 /// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers. 1759 /// This should only be called when the current token is known to be part of 1760 /// simple-type-specifier. 1761 /// 1762 /// simple-type-specifier: 1763 /// '::'[opt] nested-name-specifier[opt] type-name 1764 /// '::'[opt] nested-name-specifier 'template' simple-template-id [TODO] 1765 /// char 1766 /// wchar_t 1767 /// bool 1768 /// short 1769 /// int 1770 /// long 1771 /// signed 1772 /// unsigned 1773 /// float 1774 /// double 1775 /// void 1776 /// [GNU] typeof-specifier 1777 /// [C++0x] auto [TODO] 1778 /// 1779 /// type-name: 1780 /// class-name 1781 /// enum-name 1782 /// typedef-name 1783 /// 1784 void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) { 1785 DS.SetRangeStart(Tok.getLocation()); 1786 const char *PrevSpec; 1787 unsigned DiagID; 1788 SourceLocation Loc = Tok.getLocation(); 1789 const clang::PrintingPolicy &Policy = 1790 Actions.getASTContext().getPrintingPolicy(); 1791 1792 switch (Tok.getKind()) { 1793 case tok::identifier: // foo::bar 1794 case tok::coloncolon: // ::foo::bar 1795 llvm_unreachable("Annotation token should already be formed!"); 1796 default: 1797 llvm_unreachable("Not a simple-type-specifier token!"); 1798 1799 // type-name 1800 case tok::annot_typename: { 1801 if (getTypeAnnotation(Tok)) 1802 DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, 1803 getTypeAnnotation(Tok), Policy); 1804 else 1805 DS.SetTypeSpecError(); 1806 1807 DS.SetRangeEnd(Tok.getAnnotationEndLoc()); 1808 ConsumeToken(); 1809 1810 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id' 1811 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an 1812 // Objective-C interface. If we don't have Objective-C or a '<', this is 1813 // just a normal reference to a typedef name. 1814 if (Tok.is(tok::less) && getLangOpts().ObjC1) 1815 ParseObjCProtocolQualifiers(DS); 1816 1817 DS.Finish(Diags, PP, Policy); 1818 return; 1819 } 1820 1821 // builtin types 1822 case tok::kw_short: 1823 DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID, Policy); 1824 break; 1825 case tok::kw_long: 1826 DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, DiagID, Policy); 1827 break; 1828 case tok::kw___int64: 1829 DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, DiagID, Policy); 1830 break; 1831 case tok::kw_signed: 1832 DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID); 1833 break; 1834 case tok::kw_unsigned: 1835 DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, DiagID); 1836 break; 1837 case tok::kw_void: 1838 DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID, Policy); 1839 break; 1840 case tok::kw_char: 1841 DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID, Policy); 1842 break; 1843 case tok::kw_int: 1844 DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID, Policy); 1845 break; 1846 case tok::kw___int128: 1847 DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID, Policy); 1848 break; 1849 case tok::kw_half: 1850 DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID, Policy); 1851 break; 1852 case tok::kw_float: 1853 DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID, Policy); 1854 break; 1855 case tok::kw_double: 1856 DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID, Policy); 1857 break; 1858 case tok::kw_wchar_t: 1859 DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID, Policy); 1860 break; 1861 case tok::kw_char16_t: 1862 DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID, Policy); 1863 break; 1864 case tok::kw_char32_t: 1865 DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID, Policy); 1866 break; 1867 case tok::kw_bool: 1868 DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID, Policy); 1869 break; 1870 case tok::annot_decltype: 1871 case tok::kw_decltype: 1872 DS.SetRangeEnd(ParseDecltypeSpecifier(DS)); 1873 return DS.Finish(Diags, PP, Policy); 1874 1875 // GNU typeof support. 1876 case tok::kw_typeof: 1877 ParseTypeofSpecifier(DS); 1878 DS.Finish(Diags, PP, Policy); 1879 return; 1880 } 1881 if (Tok.is(tok::annot_typename)) 1882 DS.SetRangeEnd(Tok.getAnnotationEndLoc()); 1883 else 1884 DS.SetRangeEnd(Tok.getLocation()); 1885 ConsumeToken(); 1886 DS.Finish(Diags, PP, Policy); 1887 } 1888 1889 /// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++ 1890 /// [dcl.name]), which is a non-empty sequence of type-specifiers, 1891 /// e.g., "const short int". Note that the DeclSpec is *not* finished 1892 /// by parsing the type-specifier-seq, because these sequences are 1893 /// typically followed by some form of declarator. Returns true and 1894 /// emits diagnostics if this is not a type-specifier-seq, false 1895 /// otherwise. 1896 /// 1897 /// type-specifier-seq: [C++ 8.1] 1898 /// type-specifier type-specifier-seq[opt] 1899 /// 1900 bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) { 1901 ParseSpecifierQualifierList(DS, AS_none, DSC_type_specifier); 1902 DS.Finish(Diags, PP, Actions.getASTContext().getPrintingPolicy()); 1903 return false; 1904 } 1905 1906 /// \brief Finish parsing a C++ unqualified-id that is a template-id of 1907 /// some form. 1908 /// 1909 /// This routine is invoked when a '<' is encountered after an identifier or 1910 /// operator-function-id is parsed by \c ParseUnqualifiedId() to determine 1911 /// whether the unqualified-id is actually a template-id. This routine will 1912 /// then parse the template arguments and form the appropriate template-id to 1913 /// return to the caller. 1914 /// 1915 /// \param SS the nested-name-specifier that precedes this template-id, if 1916 /// we're actually parsing a qualified-id. 1917 /// 1918 /// \param Name for constructor and destructor names, this is the actual 1919 /// identifier that may be a template-name. 1920 /// 1921 /// \param NameLoc the location of the class-name in a constructor or 1922 /// destructor. 1923 /// 1924 /// \param EnteringContext whether we're entering the scope of the 1925 /// nested-name-specifier. 1926 /// 1927 /// \param ObjectType if this unqualified-id occurs within a member access 1928 /// expression, the type of the base object whose member is being accessed. 1929 /// 1930 /// \param Id as input, describes the template-name or operator-function-id 1931 /// that precedes the '<'. If template arguments were parsed successfully, 1932 /// will be updated with the template-id. 1933 /// 1934 /// \param AssumeTemplateId When true, this routine will assume that the name 1935 /// refers to a template without performing name lookup to verify. 1936 /// 1937 /// \returns true if a parse error occurred, false otherwise. 1938 bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS, 1939 SourceLocation TemplateKWLoc, 1940 IdentifierInfo *Name, 1941 SourceLocation NameLoc, 1942 bool EnteringContext, 1943 ParsedType ObjectType, 1944 UnqualifiedId &Id, 1945 bool AssumeTemplateId) { 1946 assert((AssumeTemplateId || Tok.is(tok::less)) && 1947 "Expected '<' to finish parsing a template-id"); 1948 1949 TemplateTy Template; 1950 TemplateNameKind TNK = TNK_Non_template; 1951 switch (Id.getKind()) { 1952 case UnqualifiedId::IK_Identifier: 1953 case UnqualifiedId::IK_OperatorFunctionId: 1954 case UnqualifiedId::IK_LiteralOperatorId: 1955 if (AssumeTemplateId) { 1956 TNK = Actions.ActOnDependentTemplateName(getCurScope(), SS, TemplateKWLoc, 1957 Id, ObjectType, EnteringContext, 1958 Template); 1959 if (TNK == TNK_Non_template) 1960 return true; 1961 } else { 1962 bool MemberOfUnknownSpecialization; 1963 TNK = Actions.isTemplateName(getCurScope(), SS, 1964 TemplateKWLoc.isValid(), Id, 1965 ObjectType, EnteringContext, Template, 1966 MemberOfUnknownSpecialization); 1967 1968 if (TNK == TNK_Non_template && MemberOfUnknownSpecialization && 1969 ObjectType && IsTemplateArgumentList()) { 1970 // We have something like t->getAs<T>(), where getAs is a 1971 // member of an unknown specialization. However, this will only 1972 // parse correctly as a template, so suggest the keyword 'template' 1973 // before 'getAs' and treat this as a dependent template name. 1974 std::string Name; 1975 if (Id.getKind() == UnqualifiedId::IK_Identifier) 1976 Name = Id.Identifier->getName(); 1977 else { 1978 Name = "operator "; 1979 if (Id.getKind() == UnqualifiedId::IK_OperatorFunctionId) 1980 Name += getOperatorSpelling(Id.OperatorFunctionId.Operator); 1981 else 1982 Name += Id.Identifier->getName(); 1983 } 1984 Diag(Id.StartLocation, diag::err_missing_dependent_template_keyword) 1985 << Name 1986 << FixItHint::CreateInsertion(Id.StartLocation, "template "); 1987 TNK = Actions.ActOnDependentTemplateName(getCurScope(), 1988 SS, TemplateKWLoc, Id, 1989 ObjectType, EnteringContext, 1990 Template); 1991 if (TNK == TNK_Non_template) 1992 return true; 1993 } 1994 } 1995 break; 1996 1997 case UnqualifiedId::IK_ConstructorName: { 1998 UnqualifiedId TemplateName; 1999 bool MemberOfUnknownSpecialization; 2000 TemplateName.setIdentifier(Name, NameLoc); 2001 TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(), 2002 TemplateName, ObjectType, 2003 EnteringContext, Template, 2004 MemberOfUnknownSpecialization); 2005 break; 2006 } 2007 2008 case UnqualifiedId::IK_DestructorName: { 2009 UnqualifiedId TemplateName; 2010 bool MemberOfUnknownSpecialization; 2011 TemplateName.setIdentifier(Name, NameLoc); 2012 if (ObjectType) { 2013 TNK = Actions.ActOnDependentTemplateName(getCurScope(), 2014 SS, TemplateKWLoc, TemplateName, 2015 ObjectType, EnteringContext, 2016 Template); 2017 if (TNK == TNK_Non_template) 2018 return true; 2019 } else { 2020 TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(), 2021 TemplateName, ObjectType, 2022 EnteringContext, Template, 2023 MemberOfUnknownSpecialization); 2024 2025 if (TNK == TNK_Non_template && !Id.DestructorName.get()) { 2026 Diag(NameLoc, diag::err_destructor_template_id) 2027 << Name << SS.getRange(); 2028 return true; 2029 } 2030 } 2031 break; 2032 } 2033 2034 default: 2035 return false; 2036 } 2037 2038 if (TNK == TNK_Non_template) 2039 return false; 2040 2041 // Parse the enclosed template argument list. 2042 SourceLocation LAngleLoc, RAngleLoc; 2043 TemplateArgList TemplateArgs; 2044 if (Tok.is(tok::less) && 2045 ParseTemplateIdAfterTemplateName(Template, Id.StartLocation, 2046 SS, true, LAngleLoc, 2047 TemplateArgs, 2048 RAngleLoc)) 2049 return true; 2050 2051 if (Id.getKind() == UnqualifiedId::IK_Identifier || 2052 Id.getKind() == UnqualifiedId::IK_OperatorFunctionId || 2053 Id.getKind() == UnqualifiedId::IK_LiteralOperatorId) { 2054 // Form a parsed representation of the template-id to be stored in the 2055 // UnqualifiedId. 2056 TemplateIdAnnotation *TemplateId 2057 = TemplateIdAnnotation::Allocate(TemplateArgs.size(), TemplateIds); 2058 2059 // FIXME: Store name for literal operator too. 2060 if (Id.getKind() == UnqualifiedId::IK_Identifier) { 2061 TemplateId->Name = Id.Identifier; 2062 TemplateId->Operator = OO_None; 2063 TemplateId->TemplateNameLoc = Id.StartLocation; 2064 } else { 2065 TemplateId->Name = nullptr; 2066 TemplateId->Operator = Id.OperatorFunctionId.Operator; 2067 TemplateId->TemplateNameLoc = Id.StartLocation; 2068 } 2069 2070 TemplateId->SS = SS; 2071 TemplateId->TemplateKWLoc = TemplateKWLoc; 2072 TemplateId->Template = Template; 2073 TemplateId->Kind = TNK; 2074 TemplateId->LAngleLoc = LAngleLoc; 2075 TemplateId->RAngleLoc = RAngleLoc; 2076 ParsedTemplateArgument *Args = TemplateId->getTemplateArgs(); 2077 for (unsigned Arg = 0, ArgEnd = TemplateArgs.size(); 2078 Arg != ArgEnd; ++Arg) 2079 Args[Arg] = TemplateArgs[Arg]; 2080 2081 Id.setTemplateId(TemplateId); 2082 return false; 2083 } 2084 2085 // Bundle the template arguments together. 2086 ASTTemplateArgsPtr TemplateArgsPtr(TemplateArgs); 2087 2088 // Constructor and destructor names. 2089 TypeResult Type 2090 = Actions.ActOnTemplateIdType(SS, TemplateKWLoc, 2091 Template, NameLoc, 2092 LAngleLoc, TemplateArgsPtr, RAngleLoc, 2093 /*IsCtorOrDtorName=*/true); 2094 if (Type.isInvalid()) 2095 return true; 2096 2097 if (Id.getKind() == UnqualifiedId::IK_ConstructorName) 2098 Id.setConstructorName(Type.get(), NameLoc, RAngleLoc); 2099 else 2100 Id.setDestructorName(Id.StartLocation, Type.get(), RAngleLoc); 2101 2102 return false; 2103 } 2104 2105 /// \brief Parse an operator-function-id or conversion-function-id as part 2106 /// of a C++ unqualified-id. 2107 /// 2108 /// This routine is responsible only for parsing the operator-function-id or 2109 /// conversion-function-id; it does not handle template arguments in any way. 2110 /// 2111 /// \code 2112 /// operator-function-id: [C++ 13.5] 2113 /// 'operator' operator 2114 /// 2115 /// operator: one of 2116 /// new delete new[] delete[] 2117 /// + - * / % ^ & | ~ 2118 /// ! = < > += -= *= /= %= 2119 /// ^= &= |= << >> >>= <<= == != 2120 /// <= >= && || ++ -- , ->* -> 2121 /// () [] 2122 /// 2123 /// conversion-function-id: [C++ 12.3.2] 2124 /// operator conversion-type-id 2125 /// 2126 /// conversion-type-id: 2127 /// type-specifier-seq conversion-declarator[opt] 2128 /// 2129 /// conversion-declarator: 2130 /// ptr-operator conversion-declarator[opt] 2131 /// \endcode 2132 /// 2133 /// \param SS The nested-name-specifier that preceded this unqualified-id. If 2134 /// non-empty, then we are parsing the unqualified-id of a qualified-id. 2135 /// 2136 /// \param EnteringContext whether we are entering the scope of the 2137 /// nested-name-specifier. 2138 /// 2139 /// \param ObjectType if this unqualified-id occurs within a member access 2140 /// expression, the type of the base object whose member is being accessed. 2141 /// 2142 /// \param Result on a successful parse, contains the parsed unqualified-id. 2143 /// 2144 /// \returns true if parsing fails, false otherwise. 2145 bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext, 2146 ParsedType ObjectType, 2147 UnqualifiedId &Result) { 2148 assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword"); 2149 2150 // Consume the 'operator' keyword. 2151 SourceLocation KeywordLoc = ConsumeToken(); 2152 2153 // Determine what kind of operator name we have. 2154 unsigned SymbolIdx = 0; 2155 SourceLocation SymbolLocations[3]; 2156 OverloadedOperatorKind Op = OO_None; 2157 switch (Tok.getKind()) { 2158 case tok::kw_new: 2159 case tok::kw_delete: { 2160 bool isNew = Tok.getKind() == tok::kw_new; 2161 // Consume the 'new' or 'delete'. 2162 SymbolLocations[SymbolIdx++] = ConsumeToken(); 2163 // Check for array new/delete. 2164 if (Tok.is(tok::l_square) && 2165 (!getLangOpts().CPlusPlus11 || NextToken().isNot(tok::l_square))) { 2166 // Consume the '[' and ']'. 2167 BalancedDelimiterTracker T(*this, tok::l_square); 2168 T.consumeOpen(); 2169 T.consumeClose(); 2170 if (T.getCloseLocation().isInvalid()) 2171 return true; 2172 2173 SymbolLocations[SymbolIdx++] = T.getOpenLocation(); 2174 SymbolLocations[SymbolIdx++] = T.getCloseLocation(); 2175 Op = isNew? OO_Array_New : OO_Array_Delete; 2176 } else { 2177 Op = isNew? OO_New : OO_Delete; 2178 } 2179 break; 2180 } 2181 2182 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 2183 case tok::Token: \ 2184 SymbolLocations[SymbolIdx++] = ConsumeToken(); \ 2185 Op = OO_##Name; \ 2186 break; 2187 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly) 2188 #include "clang/Basic/OperatorKinds.def" 2189 2190 case tok::l_paren: { 2191 // Consume the '(' and ')'. 2192 BalancedDelimiterTracker T(*this, tok::l_paren); 2193 T.consumeOpen(); 2194 T.consumeClose(); 2195 if (T.getCloseLocation().isInvalid()) 2196 return true; 2197 2198 SymbolLocations[SymbolIdx++] = T.getOpenLocation(); 2199 SymbolLocations[SymbolIdx++] = T.getCloseLocation(); 2200 Op = OO_Call; 2201 break; 2202 } 2203 2204 case tok::l_square: { 2205 // Consume the '[' and ']'. 2206 BalancedDelimiterTracker T(*this, tok::l_square); 2207 T.consumeOpen(); 2208 T.consumeClose(); 2209 if (T.getCloseLocation().isInvalid()) 2210 return true; 2211 2212 SymbolLocations[SymbolIdx++] = T.getOpenLocation(); 2213 SymbolLocations[SymbolIdx++] = T.getCloseLocation(); 2214 Op = OO_Subscript; 2215 break; 2216 } 2217 2218 case tok::code_completion: { 2219 // Code completion for the operator name. 2220 Actions.CodeCompleteOperatorName(getCurScope()); 2221 cutOffParsing(); 2222 // Don't try to parse any further. 2223 return true; 2224 } 2225 2226 default: 2227 break; 2228 } 2229 2230 if (Op != OO_None) { 2231 // We have parsed an operator-function-id. 2232 Result.setOperatorFunctionId(KeywordLoc, Op, SymbolLocations); 2233 return false; 2234 } 2235 2236 // Parse a literal-operator-id. 2237 // 2238 // literal-operator-id: C++11 [over.literal] 2239 // operator string-literal identifier 2240 // operator user-defined-string-literal 2241 2242 if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) { 2243 Diag(Tok.getLocation(), diag::warn_cxx98_compat_literal_operator); 2244 2245 SourceLocation DiagLoc; 2246 unsigned DiagId = 0; 2247 2248 // We're past translation phase 6, so perform string literal concatenation 2249 // before checking for "". 2250 SmallVector<Token, 4> Toks; 2251 SmallVector<SourceLocation, 4> TokLocs; 2252 while (isTokenStringLiteral()) { 2253 if (!Tok.is(tok::string_literal) && !DiagId) { 2254 // C++11 [over.literal]p1: 2255 // The string-literal or user-defined-string-literal in a 2256 // literal-operator-id shall have no encoding-prefix [...]. 2257 DiagLoc = Tok.getLocation(); 2258 DiagId = diag::err_literal_operator_string_prefix; 2259 } 2260 Toks.push_back(Tok); 2261 TokLocs.push_back(ConsumeStringToken()); 2262 } 2263 2264 StringLiteralParser Literal(Toks, PP); 2265 if (Literal.hadError) 2266 return true; 2267 2268 // Grab the literal operator's suffix, which will be either the next token 2269 // or a ud-suffix from the string literal. 2270 IdentifierInfo *II = nullptr; 2271 SourceLocation SuffixLoc; 2272 if (!Literal.getUDSuffix().empty()) { 2273 II = &PP.getIdentifierTable().get(Literal.getUDSuffix()); 2274 SuffixLoc = 2275 Lexer::AdvanceToTokenCharacter(TokLocs[Literal.getUDSuffixToken()], 2276 Literal.getUDSuffixOffset(), 2277 PP.getSourceManager(), getLangOpts()); 2278 } else if (Tok.is(tok::identifier)) { 2279 II = Tok.getIdentifierInfo(); 2280 SuffixLoc = ConsumeToken(); 2281 TokLocs.push_back(SuffixLoc); 2282 } else { 2283 Diag(Tok.getLocation(), diag::err_expected) << tok::identifier; 2284 return true; 2285 } 2286 2287 // The string literal must be empty. 2288 if (!Literal.GetString().empty() || Literal.Pascal) { 2289 // C++11 [over.literal]p1: 2290 // The string-literal or user-defined-string-literal in a 2291 // literal-operator-id shall [...] contain no characters 2292 // other than the implicit terminating '\0'. 2293 DiagLoc = TokLocs.front(); 2294 DiagId = diag::err_literal_operator_string_not_empty; 2295 } 2296 2297 if (DiagId) { 2298 // This isn't a valid literal-operator-id, but we think we know 2299 // what the user meant. Tell them what they should have written. 2300 SmallString<32> Str; 2301 Str += "\"\" "; 2302 Str += II->getName(); 2303 Diag(DiagLoc, DiagId) << FixItHint::CreateReplacement( 2304 SourceRange(TokLocs.front(), TokLocs.back()), Str); 2305 } 2306 2307 Result.setLiteralOperatorId(II, KeywordLoc, SuffixLoc); 2308 2309 return Actions.checkLiteralOperatorId(SS, Result); 2310 } 2311 2312 // Parse a conversion-function-id. 2313 // 2314 // conversion-function-id: [C++ 12.3.2] 2315 // operator conversion-type-id 2316 // 2317 // conversion-type-id: 2318 // type-specifier-seq conversion-declarator[opt] 2319 // 2320 // conversion-declarator: 2321 // ptr-operator conversion-declarator[opt] 2322 2323 // Parse the type-specifier-seq. 2324 DeclSpec DS(AttrFactory); 2325 if (ParseCXXTypeSpecifierSeq(DS)) // FIXME: ObjectType? 2326 return true; 2327 2328 // Parse the conversion-declarator, which is merely a sequence of 2329 // ptr-operators. 2330 Declarator D(DS, Declarator::ConversionIdContext); 2331 ParseDeclaratorInternal(D, /*DirectDeclParser=*/nullptr); 2332 2333 // Finish up the type. 2334 TypeResult Ty = Actions.ActOnTypeName(getCurScope(), D); 2335 if (Ty.isInvalid()) 2336 return true; 2337 2338 // Note that this is a conversion-function-id. 2339 Result.setConversionFunctionId(KeywordLoc, Ty.get(), 2340 D.getSourceRange().getEnd()); 2341 return false; 2342 } 2343 2344 /// \brief Parse a C++ unqualified-id (or a C identifier), which describes the 2345 /// name of an entity. 2346 /// 2347 /// \code 2348 /// unqualified-id: [C++ expr.prim.general] 2349 /// identifier 2350 /// operator-function-id 2351 /// conversion-function-id 2352 /// [C++0x] literal-operator-id [TODO] 2353 /// ~ class-name 2354 /// template-id 2355 /// 2356 /// \endcode 2357 /// 2358 /// \param SS The nested-name-specifier that preceded this unqualified-id. If 2359 /// non-empty, then we are parsing the unqualified-id of a qualified-id. 2360 /// 2361 /// \param EnteringContext whether we are entering the scope of the 2362 /// nested-name-specifier. 2363 /// 2364 /// \param AllowDestructorName whether we allow parsing of a destructor name. 2365 /// 2366 /// \param AllowConstructorName whether we allow parsing a constructor name. 2367 /// 2368 /// \param ObjectType if this unqualified-id occurs within a member access 2369 /// expression, the type of the base object whose member is being accessed. 2370 /// 2371 /// \param Result on a successful parse, contains the parsed unqualified-id. 2372 /// 2373 /// \returns true if parsing fails, false otherwise. 2374 bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext, 2375 bool AllowDestructorName, 2376 bool AllowConstructorName, 2377 ParsedType ObjectType, 2378 SourceLocation& TemplateKWLoc, 2379 UnqualifiedId &Result) { 2380 2381 // Handle 'A::template B'. This is for template-ids which have not 2382 // already been annotated by ParseOptionalCXXScopeSpecifier(). 2383 bool TemplateSpecified = false; 2384 if (getLangOpts().CPlusPlus && Tok.is(tok::kw_template) && 2385 (ObjectType || SS.isSet())) { 2386 TemplateSpecified = true; 2387 TemplateKWLoc = ConsumeToken(); 2388 } 2389 2390 // unqualified-id: 2391 // identifier 2392 // template-id (when it hasn't already been annotated) 2393 if (Tok.is(tok::identifier)) { 2394 // Consume the identifier. 2395 IdentifierInfo *Id = Tok.getIdentifierInfo(); 2396 SourceLocation IdLoc = ConsumeToken(); 2397 2398 if (!getLangOpts().CPlusPlus) { 2399 // If we're not in C++, only identifiers matter. Record the 2400 // identifier and return. 2401 Result.setIdentifier(Id, IdLoc); 2402 return false; 2403 } 2404 2405 if (AllowConstructorName && 2406 Actions.isCurrentClassName(*Id, getCurScope(), &SS)) { 2407 // We have parsed a constructor name. 2408 ParsedType Ty = Actions.getTypeName(*Id, IdLoc, getCurScope(), 2409 &SS, false, false, 2410 ParsedType(), 2411 /*IsCtorOrDtorName=*/true, 2412 /*NonTrivialTypeSourceInfo=*/true); 2413 Result.setConstructorName(Ty, IdLoc, IdLoc); 2414 } else { 2415 // We have parsed an identifier. 2416 Result.setIdentifier(Id, IdLoc); 2417 } 2418 2419 // If the next token is a '<', we may have a template. 2420 if (TemplateSpecified || Tok.is(tok::less)) 2421 return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc, Id, IdLoc, 2422 EnteringContext, ObjectType, 2423 Result, TemplateSpecified); 2424 2425 return false; 2426 } 2427 2428 // unqualified-id: 2429 // template-id (already parsed and annotated) 2430 if (Tok.is(tok::annot_template_id)) { 2431 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); 2432 2433 // If the template-name names the current class, then this is a constructor 2434 if (AllowConstructorName && TemplateId->Name && 2435 Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) { 2436 if (SS.isSet()) { 2437 // C++ [class.qual]p2 specifies that a qualified template-name 2438 // is taken as the constructor name where a constructor can be 2439 // declared. Thus, the template arguments are extraneous, so 2440 // complain about them and remove them entirely. 2441 Diag(TemplateId->TemplateNameLoc, 2442 diag::err_out_of_line_constructor_template_id) 2443 << TemplateId->Name 2444 << FixItHint::CreateRemoval( 2445 SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc)); 2446 ParsedType Ty = Actions.getTypeName(*TemplateId->Name, 2447 TemplateId->TemplateNameLoc, 2448 getCurScope(), 2449 &SS, false, false, 2450 ParsedType(), 2451 /*IsCtorOrDtorName=*/true, 2452 /*NontrivialTypeSourceInfo=*/true); 2453 Result.setConstructorName(Ty, TemplateId->TemplateNameLoc, 2454 TemplateId->RAngleLoc); 2455 ConsumeToken(); 2456 return false; 2457 } 2458 2459 Result.setConstructorTemplateId(TemplateId); 2460 ConsumeToken(); 2461 return false; 2462 } 2463 2464 // We have already parsed a template-id; consume the annotation token as 2465 // our unqualified-id. 2466 Result.setTemplateId(TemplateId); 2467 TemplateKWLoc = TemplateId->TemplateKWLoc; 2468 ConsumeToken(); 2469 return false; 2470 } 2471 2472 // unqualified-id: 2473 // operator-function-id 2474 // conversion-function-id 2475 if (Tok.is(tok::kw_operator)) { 2476 if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, Result)) 2477 return true; 2478 2479 // If we have an operator-function-id or a literal-operator-id and the next 2480 // token is a '<', we may have a 2481 // 2482 // template-id: 2483 // operator-function-id < template-argument-list[opt] > 2484 if ((Result.getKind() == UnqualifiedId::IK_OperatorFunctionId || 2485 Result.getKind() == UnqualifiedId::IK_LiteralOperatorId) && 2486 (TemplateSpecified || Tok.is(tok::less))) 2487 return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc, 2488 nullptr, SourceLocation(), 2489 EnteringContext, ObjectType, 2490 Result, TemplateSpecified); 2491 2492 return false; 2493 } 2494 2495 if (getLangOpts().CPlusPlus && 2496 (AllowDestructorName || SS.isSet()) && Tok.is(tok::tilde)) { 2497 // C++ [expr.unary.op]p10: 2498 // There is an ambiguity in the unary-expression ~X(), where X is a 2499 // class-name. The ambiguity is resolved in favor of treating ~ as a 2500 // unary complement rather than treating ~X as referring to a destructor. 2501 2502 // Parse the '~'. 2503 SourceLocation TildeLoc = ConsumeToken(); 2504 2505 if (SS.isEmpty() && Tok.is(tok::kw_decltype)) { 2506 DeclSpec DS(AttrFactory); 2507 SourceLocation EndLoc = ParseDecltypeSpecifier(DS); 2508 if (ParsedType Type = Actions.getDestructorType(DS, ObjectType)) { 2509 Result.setDestructorName(TildeLoc, Type, EndLoc); 2510 return false; 2511 } 2512 return true; 2513 } 2514 2515 // Parse the class-name. 2516 if (Tok.isNot(tok::identifier)) { 2517 Diag(Tok, diag::err_destructor_tilde_identifier); 2518 return true; 2519 } 2520 2521 // If the user wrote ~T::T, correct it to T::~T. 2522 DeclaratorScopeObj DeclScopeObj(*this, SS); 2523 if (!TemplateSpecified && NextToken().is(tok::coloncolon)) { 2524 // Don't let ParseOptionalCXXScopeSpecifier() "correct" 2525 // `int A; struct { ~A::A(); };` to `int A; struct { ~A:A(); };`, 2526 // it will confuse this recovery logic. 2527 ColonProtectionRAIIObject ColonRAII(*this, false); 2528 2529 if (SS.isSet()) { 2530 AnnotateScopeToken(SS, /*NewAnnotation*/true); 2531 SS.clear(); 2532 } 2533 if (ParseOptionalCXXScopeSpecifier(SS, ObjectType, EnteringContext)) 2534 return true; 2535 if (SS.isNotEmpty()) 2536 ObjectType = ParsedType(); 2537 if (Tok.isNot(tok::identifier) || NextToken().is(tok::coloncolon) || 2538 !SS.isSet()) { 2539 Diag(TildeLoc, diag::err_destructor_tilde_scope); 2540 return true; 2541 } 2542 2543 // Recover as if the tilde had been written before the identifier. 2544 Diag(TildeLoc, diag::err_destructor_tilde_scope) 2545 << FixItHint::CreateRemoval(TildeLoc) 2546 << FixItHint::CreateInsertion(Tok.getLocation(), "~"); 2547 2548 // Temporarily enter the scope for the rest of this function. 2549 if (Actions.ShouldEnterDeclaratorScope(getCurScope(), SS)) 2550 DeclScopeObj.EnterDeclaratorScope(); 2551 } 2552 2553 // Parse the class-name (or template-name in a simple-template-id). 2554 IdentifierInfo *ClassName = Tok.getIdentifierInfo(); 2555 SourceLocation ClassNameLoc = ConsumeToken(); 2556 2557 if (TemplateSpecified || Tok.is(tok::less)) { 2558 Result.setDestructorName(TildeLoc, ParsedType(), ClassNameLoc); 2559 return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc, 2560 ClassName, ClassNameLoc, 2561 EnteringContext, ObjectType, 2562 Result, TemplateSpecified); 2563 } 2564 2565 // Note that this is a destructor name. 2566 ParsedType Ty = Actions.getDestructorName(TildeLoc, *ClassName, 2567 ClassNameLoc, getCurScope(), 2568 SS, ObjectType, 2569 EnteringContext); 2570 if (!Ty) 2571 return true; 2572 2573 Result.setDestructorName(TildeLoc, Ty, ClassNameLoc); 2574 return false; 2575 } 2576 2577 Diag(Tok, diag::err_expected_unqualified_id) 2578 << getLangOpts().CPlusPlus; 2579 return true; 2580 } 2581 2582 /// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate 2583 /// memory in a typesafe manner and call constructors. 2584 /// 2585 /// This method is called to parse the new expression after the optional :: has 2586 /// been already parsed. If the :: was present, "UseGlobal" is true and "Start" 2587 /// is its location. Otherwise, "Start" is the location of the 'new' token. 2588 /// 2589 /// new-expression: 2590 /// '::'[opt] 'new' new-placement[opt] new-type-id 2591 /// new-initializer[opt] 2592 /// '::'[opt] 'new' new-placement[opt] '(' type-id ')' 2593 /// new-initializer[opt] 2594 /// 2595 /// new-placement: 2596 /// '(' expression-list ')' 2597 /// 2598 /// new-type-id: 2599 /// type-specifier-seq new-declarator[opt] 2600 /// [GNU] attributes type-specifier-seq new-declarator[opt] 2601 /// 2602 /// new-declarator: 2603 /// ptr-operator new-declarator[opt] 2604 /// direct-new-declarator 2605 /// 2606 /// new-initializer: 2607 /// '(' expression-list[opt] ')' 2608 /// [C++0x] braced-init-list 2609 /// 2610 ExprResult 2611 Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) { 2612 assert(Tok.is(tok::kw_new) && "expected 'new' token"); 2613 ConsumeToken(); // Consume 'new' 2614 2615 // A '(' now can be a new-placement or the '(' wrapping the type-id in the 2616 // second form of new-expression. It can't be a new-type-id. 2617 2618 ExprVector PlacementArgs; 2619 SourceLocation PlacementLParen, PlacementRParen; 2620 2621 SourceRange TypeIdParens; 2622 DeclSpec DS(AttrFactory); 2623 Declarator DeclaratorInfo(DS, Declarator::CXXNewContext); 2624 if (Tok.is(tok::l_paren)) { 2625 // If it turns out to be a placement, we change the type location. 2626 BalancedDelimiterTracker T(*this, tok::l_paren); 2627 T.consumeOpen(); 2628 PlacementLParen = T.getOpenLocation(); 2629 if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) { 2630 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch); 2631 return ExprError(); 2632 } 2633 2634 T.consumeClose(); 2635 PlacementRParen = T.getCloseLocation(); 2636 if (PlacementRParen.isInvalid()) { 2637 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch); 2638 return ExprError(); 2639 } 2640 2641 if (PlacementArgs.empty()) { 2642 // Reset the placement locations. There was no placement. 2643 TypeIdParens = T.getRange(); 2644 PlacementLParen = PlacementRParen = SourceLocation(); 2645 } else { 2646 // We still need the type. 2647 if (Tok.is(tok::l_paren)) { 2648 BalancedDelimiterTracker T(*this, tok::l_paren); 2649 T.consumeOpen(); 2650 MaybeParseGNUAttributes(DeclaratorInfo); 2651 ParseSpecifierQualifierList(DS); 2652 DeclaratorInfo.SetSourceRange(DS.getSourceRange()); 2653 ParseDeclarator(DeclaratorInfo); 2654 T.consumeClose(); 2655 TypeIdParens = T.getRange(); 2656 } else { 2657 MaybeParseGNUAttributes(DeclaratorInfo); 2658 if (ParseCXXTypeSpecifierSeq(DS)) 2659 DeclaratorInfo.setInvalidType(true); 2660 else { 2661 DeclaratorInfo.SetSourceRange(DS.getSourceRange()); 2662 ParseDeclaratorInternal(DeclaratorInfo, 2663 &Parser::ParseDirectNewDeclarator); 2664 } 2665 } 2666 } 2667 } else { 2668 // A new-type-id is a simplified type-id, where essentially the 2669 // direct-declarator is replaced by a direct-new-declarator. 2670 MaybeParseGNUAttributes(DeclaratorInfo); 2671 if (ParseCXXTypeSpecifierSeq(DS)) 2672 DeclaratorInfo.setInvalidType(true); 2673 else { 2674 DeclaratorInfo.SetSourceRange(DS.getSourceRange()); 2675 ParseDeclaratorInternal(DeclaratorInfo, 2676 &Parser::ParseDirectNewDeclarator); 2677 } 2678 } 2679 if (DeclaratorInfo.isInvalidType()) { 2680 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch); 2681 return ExprError(); 2682 } 2683 2684 ExprResult Initializer; 2685 2686 if (Tok.is(tok::l_paren)) { 2687 SourceLocation ConstructorLParen, ConstructorRParen; 2688 ExprVector ConstructorArgs; 2689 BalancedDelimiterTracker T(*this, tok::l_paren); 2690 T.consumeOpen(); 2691 ConstructorLParen = T.getOpenLocation(); 2692 if (Tok.isNot(tok::r_paren)) { 2693 CommaLocsTy CommaLocs; 2694 if (ParseExpressionList(ConstructorArgs, CommaLocs, [&] { 2695 ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), 2696 DeclaratorInfo).get(); 2697 Actions.CodeCompleteConstructor(getCurScope(), 2698 TypeRep.get()->getCanonicalTypeInternal(), 2699 DeclaratorInfo.getLocEnd(), 2700 ConstructorArgs); 2701 })) { 2702 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch); 2703 return ExprError(); 2704 } 2705 } 2706 T.consumeClose(); 2707 ConstructorRParen = T.getCloseLocation(); 2708 if (ConstructorRParen.isInvalid()) { 2709 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch); 2710 return ExprError(); 2711 } 2712 Initializer = Actions.ActOnParenListExpr(ConstructorLParen, 2713 ConstructorRParen, 2714 ConstructorArgs); 2715 } else if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus11) { 2716 Diag(Tok.getLocation(), 2717 diag::warn_cxx98_compat_generalized_initializer_lists); 2718 Initializer = ParseBraceInitializer(); 2719 } 2720 if (Initializer.isInvalid()) 2721 return Initializer; 2722 2723 return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen, 2724 PlacementArgs, PlacementRParen, 2725 TypeIdParens, DeclaratorInfo, Initializer.get()); 2726 } 2727 2728 /// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be 2729 /// passed to ParseDeclaratorInternal. 2730 /// 2731 /// direct-new-declarator: 2732 /// '[' expression ']' 2733 /// direct-new-declarator '[' constant-expression ']' 2734 /// 2735 void Parser::ParseDirectNewDeclarator(Declarator &D) { 2736 // Parse the array dimensions. 2737 bool first = true; 2738 while (Tok.is(tok::l_square)) { 2739 // An array-size expression can't start with a lambda. 2740 if (CheckProhibitedCXX11Attribute()) 2741 continue; 2742 2743 BalancedDelimiterTracker T(*this, tok::l_square); 2744 T.consumeOpen(); 2745 2746 ExprResult Size(first ? ParseExpression() 2747 : ParseConstantExpression()); 2748 if (Size.isInvalid()) { 2749 // Recover 2750 SkipUntil(tok::r_square, StopAtSemi); 2751 return; 2752 } 2753 first = false; 2754 2755 T.consumeClose(); 2756 2757 // Attributes here appertain to the array type. C++11 [expr.new]p5. 2758 ParsedAttributes Attrs(AttrFactory); 2759 MaybeParseCXX11Attributes(Attrs); 2760 2761 D.AddTypeInfo(DeclaratorChunk::getArray(0, 2762 /*static=*/false, /*star=*/false, 2763 Size.get(), 2764 T.getOpenLocation(), 2765 T.getCloseLocation()), 2766 Attrs, T.getCloseLocation()); 2767 2768 if (T.getCloseLocation().isInvalid()) 2769 return; 2770 } 2771 } 2772 2773 /// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id. 2774 /// This ambiguity appears in the syntax of the C++ new operator. 2775 /// 2776 /// new-expression: 2777 /// '::'[opt] 'new' new-placement[opt] '(' type-id ')' 2778 /// new-initializer[opt] 2779 /// 2780 /// new-placement: 2781 /// '(' expression-list ')' 2782 /// 2783 bool Parser::ParseExpressionListOrTypeId( 2784 SmallVectorImpl<Expr*> &PlacementArgs, 2785 Declarator &D) { 2786 // The '(' was already consumed. 2787 if (isTypeIdInParens()) { 2788 ParseSpecifierQualifierList(D.getMutableDeclSpec()); 2789 D.SetSourceRange(D.getDeclSpec().getSourceRange()); 2790 ParseDeclarator(D); 2791 return D.isInvalidType(); 2792 } 2793 2794 // It's not a type, it has to be an expression list. 2795 // Discard the comma locations - ActOnCXXNew has enough parameters. 2796 CommaLocsTy CommaLocs; 2797 return ParseExpressionList(PlacementArgs, CommaLocs); 2798 } 2799 2800 /// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used 2801 /// to free memory allocated by new. 2802 /// 2803 /// This method is called to parse the 'delete' expression after the optional 2804 /// '::' has been already parsed. If the '::' was present, "UseGlobal" is true 2805 /// and "Start" is its location. Otherwise, "Start" is the location of the 2806 /// 'delete' token. 2807 /// 2808 /// delete-expression: 2809 /// '::'[opt] 'delete' cast-expression 2810 /// '::'[opt] 'delete' '[' ']' cast-expression 2811 ExprResult 2812 Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) { 2813 assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword"); 2814 ConsumeToken(); // Consume 'delete' 2815 2816 // Array delete? 2817 bool ArrayDelete = false; 2818 if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) { 2819 // C++11 [expr.delete]p1: 2820 // Whenever the delete keyword is followed by empty square brackets, it 2821 // shall be interpreted as [array delete]. 2822 // [Footnote: A lambda expression with a lambda-introducer that consists 2823 // of empty square brackets can follow the delete keyword if 2824 // the lambda expression is enclosed in parentheses.] 2825 // FIXME: Produce a better diagnostic if the '[]' is unambiguously a 2826 // lambda-introducer. 2827 ArrayDelete = true; 2828 BalancedDelimiterTracker T(*this, tok::l_square); 2829 2830 T.consumeOpen(); 2831 T.consumeClose(); 2832 if (T.getCloseLocation().isInvalid()) 2833 return ExprError(); 2834 } 2835 2836 ExprResult Operand(ParseCastExpression(false)); 2837 if (Operand.isInvalid()) 2838 return Operand; 2839 2840 return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.get()); 2841 } 2842 2843 static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) { 2844 switch (kind) { 2845 default: llvm_unreachable("Not a known type trait"); 2846 #define TYPE_TRAIT_1(Spelling, Name, Key) \ 2847 case tok::kw_ ## Spelling: return UTT_ ## Name; 2848 #define TYPE_TRAIT_2(Spelling, Name, Key) \ 2849 case tok::kw_ ## Spelling: return BTT_ ## Name; 2850 #include "clang/Basic/TokenKinds.def" 2851 #define TYPE_TRAIT_N(Spelling, Name, Key) \ 2852 case tok::kw_ ## Spelling: return TT_ ## Name; 2853 #include "clang/Basic/TokenKinds.def" 2854 } 2855 } 2856 2857 static ArrayTypeTrait ArrayTypeTraitFromTokKind(tok::TokenKind kind) { 2858 switch(kind) { 2859 default: llvm_unreachable("Not a known binary type trait"); 2860 case tok::kw___array_rank: return ATT_ArrayRank; 2861 case tok::kw___array_extent: return ATT_ArrayExtent; 2862 } 2863 } 2864 2865 static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind) { 2866 switch(kind) { 2867 default: llvm_unreachable("Not a known unary expression trait."); 2868 case tok::kw___is_lvalue_expr: return ET_IsLValueExpr; 2869 case tok::kw___is_rvalue_expr: return ET_IsRValueExpr; 2870 } 2871 } 2872 2873 static unsigned TypeTraitArity(tok::TokenKind kind) { 2874 switch (kind) { 2875 default: llvm_unreachable("Not a known type trait"); 2876 #define TYPE_TRAIT(N,Spelling,K) case tok::kw_##Spelling: return N; 2877 #include "clang/Basic/TokenKinds.def" 2878 } 2879 } 2880 2881 /// \brief Parse the built-in type-trait pseudo-functions that allow 2882 /// implementation of the TR1/C++11 type traits templates. 2883 /// 2884 /// primary-expression: 2885 /// unary-type-trait '(' type-id ')' 2886 /// binary-type-trait '(' type-id ',' type-id ')' 2887 /// type-trait '(' type-id-seq ')' 2888 /// 2889 /// type-id-seq: 2890 /// type-id ...[opt] type-id-seq[opt] 2891 /// 2892 ExprResult Parser::ParseTypeTrait() { 2893 tok::TokenKind Kind = Tok.getKind(); 2894 unsigned Arity = TypeTraitArity(Kind); 2895 2896 SourceLocation Loc = ConsumeToken(); 2897 2898 BalancedDelimiterTracker Parens(*this, tok::l_paren); 2899 if (Parens.expectAndConsume()) 2900 return ExprError(); 2901 2902 SmallVector<ParsedType, 2> Args; 2903 do { 2904 // Parse the next type. 2905 TypeResult Ty = ParseTypeName(); 2906 if (Ty.isInvalid()) { 2907 Parens.skipToEnd(); 2908 return ExprError(); 2909 } 2910 2911 // Parse the ellipsis, if present. 2912 if (Tok.is(tok::ellipsis)) { 2913 Ty = Actions.ActOnPackExpansion(Ty.get(), ConsumeToken()); 2914 if (Ty.isInvalid()) { 2915 Parens.skipToEnd(); 2916 return ExprError(); 2917 } 2918 } 2919 2920 // Add this type to the list of arguments. 2921 Args.push_back(Ty.get()); 2922 } while (TryConsumeToken(tok::comma)); 2923 2924 if (Parens.consumeClose()) 2925 return ExprError(); 2926 2927 SourceLocation EndLoc = Parens.getCloseLocation(); 2928 2929 if (Arity && Args.size() != Arity) { 2930 Diag(EndLoc, diag::err_type_trait_arity) 2931 << Arity << 0 << (Arity > 1) << (int)Args.size() << SourceRange(Loc); 2932 return ExprError(); 2933 } 2934 2935 if (!Arity && Args.empty()) { 2936 Diag(EndLoc, diag::err_type_trait_arity) 2937 << 1 << 1 << 1 << (int)Args.size() << SourceRange(Loc); 2938 return ExprError(); 2939 } 2940 2941 return Actions.ActOnTypeTrait(TypeTraitFromTokKind(Kind), Loc, Args, EndLoc); 2942 } 2943 2944 /// ParseArrayTypeTrait - Parse the built-in array type-trait 2945 /// pseudo-functions. 2946 /// 2947 /// primary-expression: 2948 /// [Embarcadero] '__array_rank' '(' type-id ')' 2949 /// [Embarcadero] '__array_extent' '(' type-id ',' expression ')' 2950 /// 2951 ExprResult Parser::ParseArrayTypeTrait() { 2952 ArrayTypeTrait ATT = ArrayTypeTraitFromTokKind(Tok.getKind()); 2953 SourceLocation Loc = ConsumeToken(); 2954 2955 BalancedDelimiterTracker T(*this, tok::l_paren); 2956 if (T.expectAndConsume()) 2957 return ExprError(); 2958 2959 TypeResult Ty = ParseTypeName(); 2960 if (Ty.isInvalid()) { 2961 SkipUntil(tok::comma, StopAtSemi); 2962 SkipUntil(tok::r_paren, StopAtSemi); 2963 return ExprError(); 2964 } 2965 2966 switch (ATT) { 2967 case ATT_ArrayRank: { 2968 T.consumeClose(); 2969 return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), nullptr, 2970 T.getCloseLocation()); 2971 } 2972 case ATT_ArrayExtent: { 2973 if (ExpectAndConsume(tok::comma)) { 2974 SkipUntil(tok::r_paren, StopAtSemi); 2975 return ExprError(); 2976 } 2977 2978 ExprResult DimExpr = ParseExpression(); 2979 T.consumeClose(); 2980 2981 return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), DimExpr.get(), 2982 T.getCloseLocation()); 2983 } 2984 } 2985 llvm_unreachable("Invalid ArrayTypeTrait!"); 2986 } 2987 2988 /// ParseExpressionTrait - Parse built-in expression-trait 2989 /// pseudo-functions like __is_lvalue_expr( xxx ). 2990 /// 2991 /// primary-expression: 2992 /// [Embarcadero] expression-trait '(' expression ')' 2993 /// 2994 ExprResult Parser::ParseExpressionTrait() { 2995 ExpressionTrait ET = ExpressionTraitFromTokKind(Tok.getKind()); 2996 SourceLocation Loc = ConsumeToken(); 2997 2998 BalancedDelimiterTracker T(*this, tok::l_paren); 2999 if (T.expectAndConsume()) 3000 return ExprError(); 3001 3002 ExprResult Expr = ParseExpression(); 3003 3004 T.consumeClose(); 3005 3006 return Actions.ActOnExpressionTrait(ET, Loc, Expr.get(), 3007 T.getCloseLocation()); 3008 } 3009 3010 3011 /// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a 3012 /// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate 3013 /// based on the context past the parens. 3014 ExprResult 3015 Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType, 3016 ParsedType &CastTy, 3017 BalancedDelimiterTracker &Tracker, 3018 ColonProtectionRAIIObject &ColonProt) { 3019 assert(getLangOpts().CPlusPlus && "Should only be called for C++!"); 3020 assert(ExprType == CastExpr && "Compound literals are not ambiguous!"); 3021 assert(isTypeIdInParens() && "Not a type-id!"); 3022 3023 ExprResult Result(true); 3024 CastTy = ParsedType(); 3025 3026 // We need to disambiguate a very ugly part of the C++ syntax: 3027 // 3028 // (T())x; - type-id 3029 // (T())*x; - type-id 3030 // (T())/x; - expression 3031 // (T()); - expression 3032 // 3033 // The bad news is that we cannot use the specialized tentative parser, since 3034 // it can only verify that the thing inside the parens can be parsed as 3035 // type-id, it is not useful for determining the context past the parens. 3036 // 3037 // The good news is that the parser can disambiguate this part without 3038 // making any unnecessary Action calls. 3039 // 3040 // It uses a scheme similar to parsing inline methods. The parenthesized 3041 // tokens are cached, the context that follows is determined (possibly by 3042 // parsing a cast-expression), and then we re-introduce the cached tokens 3043 // into the token stream and parse them appropriately. 3044 3045 ParenParseOption ParseAs; 3046 CachedTokens Toks; 3047 3048 // Store the tokens of the parentheses. We will parse them after we determine 3049 // the context that follows them. 3050 if (!ConsumeAndStoreUntil(tok::r_paren, Toks)) { 3051 // We didn't find the ')' we expected. 3052 Tracker.consumeClose(); 3053 return ExprError(); 3054 } 3055 3056 if (Tok.is(tok::l_brace)) { 3057 ParseAs = CompoundLiteral; 3058 } else { 3059 bool NotCastExpr; 3060 if (Tok.is(tok::l_paren) && NextToken().is(tok::r_paren)) { 3061 NotCastExpr = true; 3062 } else { 3063 // Try parsing the cast-expression that may follow. 3064 // If it is not a cast-expression, NotCastExpr will be true and no token 3065 // will be consumed. 3066 ColonProt.restore(); 3067 Result = ParseCastExpression(false/*isUnaryExpression*/, 3068 false/*isAddressofOperand*/, 3069 NotCastExpr, 3070 // type-id has priority. 3071 IsTypeCast); 3072 } 3073 3074 // If we parsed a cast-expression, it's really a type-id, otherwise it's 3075 // an expression. 3076 ParseAs = NotCastExpr ? SimpleExpr : CastExpr; 3077 } 3078 3079 // The current token should go after the cached tokens. 3080 Toks.push_back(Tok); 3081 // Re-enter the stored parenthesized tokens into the token stream, so we may 3082 // parse them now. 3083 PP.EnterTokenStream(Toks.data(), Toks.size(), 3084 true/*DisableMacroExpansion*/, false/*OwnsTokens*/); 3085 // Drop the current token and bring the first cached one. It's the same token 3086 // as when we entered this function. 3087 ConsumeAnyToken(); 3088 3089 if (ParseAs >= CompoundLiteral) { 3090 // Parse the type declarator. 3091 DeclSpec DS(AttrFactory); 3092 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext); 3093 { 3094 ColonProtectionRAIIObject InnerColonProtection(*this); 3095 ParseSpecifierQualifierList(DS); 3096 ParseDeclarator(DeclaratorInfo); 3097 } 3098 3099 // Match the ')'. 3100 Tracker.consumeClose(); 3101 ColonProt.restore(); 3102 3103 if (ParseAs == CompoundLiteral) { 3104 ExprType = CompoundLiteral; 3105 if (DeclaratorInfo.isInvalidType()) 3106 return ExprError(); 3107 3108 TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo); 3109 return ParseCompoundLiteralExpression(Ty.get(), 3110 Tracker.getOpenLocation(), 3111 Tracker.getCloseLocation()); 3112 } 3113 3114 // We parsed '(' type-id ')' and the thing after it wasn't a '{'. 3115 assert(ParseAs == CastExpr); 3116 3117 if (DeclaratorInfo.isInvalidType()) 3118 return ExprError(); 3119 3120 // Result is what ParseCastExpression returned earlier. 3121 if (!Result.isInvalid()) 3122 Result = Actions.ActOnCastExpr(getCurScope(), Tracker.getOpenLocation(), 3123 DeclaratorInfo, CastTy, 3124 Tracker.getCloseLocation(), Result.get()); 3125 return Result; 3126 } 3127 3128 // Not a compound literal, and not followed by a cast-expression. 3129 assert(ParseAs == SimpleExpr); 3130 3131 ExprType = SimpleExpr; 3132 Result = ParseExpression(); 3133 if (!Result.isInvalid() && Tok.is(tok::r_paren)) 3134 Result = Actions.ActOnParenExpr(Tracker.getOpenLocation(), 3135 Tok.getLocation(), Result.get()); 3136 3137 // Match the ')'. 3138 if (Result.isInvalid()) { 3139 SkipUntil(tok::r_paren, StopAtSemi); 3140 return ExprError(); 3141 } 3142 3143 Tracker.consumeClose(); 3144 return Result; 3145 } 3146