1//===--- ParseExprCXX.cpp - C++ Expression Parsing ------------------------===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This file implements the Expression parsing implementation for C++. 10// 11//===----------------------------------------------------------------------===// 12#include "clang/Parse/Parser.h" 13#include "clang/AST/ASTContext.h" 14#include "clang/AST/Decl.h" 15#include "clang/AST/DeclTemplate.h" 16#include "clang/AST/ExprCXX.h" 17#include "clang/Basic/PrettyStackTrace.h" 18#include "clang/Lex/LiteralSupport.h" 19#include "clang/Parse/ParseDiagnostic.h" 20#include "clang/Parse/RAIIObjectsForParser.h" 21#include "clang/Sema/DeclSpec.h" 22#include "clang/Sema/ParsedTemplate.h" 23#include "clang/Sema/Scope.h" 24#include "llvm/Support/ErrorHandling.h" 25#include <numeric> 26 27using namespace clang; 28 29static int SelectDigraphErrorMessage(tok::TokenKind Kind) { 30 switch (Kind) { 31 // template name 32 case tok::unknown: return 0; 33 // casts 34 case tok::kw_addrspace_cast: return 1; 35 case tok::kw_const_cast: return 2; 36 case tok::kw_dynamic_cast: return 3; 37 case tok::kw_reinterpret_cast: return 4; 38 case tok::kw_static_cast: return 5; 39 default: 40 llvm_unreachable("Unknown type for digraph error message."); 41 } 42} 43 44// Are the two tokens adjacent in the same source file? 45bool Parser::areTokensAdjacent(const Token &First, const Token &Second) { 46 SourceManager &SM = PP.getSourceManager(); 47 SourceLocation FirstLoc = SM.getSpellingLoc(First.getLocation()); 48 SourceLocation FirstEnd = FirstLoc.getLocWithOffset(First.getLength()); 49 return FirstEnd == SM.getSpellingLoc(Second.getLocation()); 50} 51 52// Suggest fixit for "<::" after a cast. 53static void FixDigraph(Parser &P, Preprocessor &PP, Token &DigraphToken, 54 Token &ColonToken, tok::TokenKind Kind, bool AtDigraph) { 55 // Pull '<:' and ':' off token stream. 56 if (!AtDigraph) 57 PP.Lex(DigraphToken); 58 PP.Lex(ColonToken); 59 60 SourceRange Range; 61 Range.setBegin(DigraphToken.getLocation()); 62 Range.setEnd(ColonToken.getLocation()); 63 P.Diag(DigraphToken.getLocation(), diag::err_missing_whitespace_digraph) 64 << SelectDigraphErrorMessage(Kind) 65 << FixItHint::CreateReplacement(Range, "< ::"); 66 67 // Update token information to reflect their change in token type. 68 ColonToken.setKind(tok::coloncolon); 69 ColonToken.setLocation(ColonToken.getLocation().getLocWithOffset(-1)); 70 ColonToken.setLength(2); 71 DigraphToken.setKind(tok::less); 72 DigraphToken.setLength(1); 73 74 // Push new tokens back to token stream. 75 PP.EnterToken(ColonToken, /*IsReinject*/ true); 76 if (!AtDigraph) 77 PP.EnterToken(DigraphToken, /*IsReinject*/ true); 78} 79 80// Check for '<::' which should be '< ::' instead of '[:' when following 81// a template name. 82void Parser::CheckForTemplateAndDigraph(Token &Next, ParsedType ObjectType, 83 bool EnteringContext, 84 IdentifierInfo &II, CXXScopeSpec &SS) { 85 if (!Next.is(tok::l_square) || Next.getLength() != 2) 86 return; 87 88 Token SecondToken = GetLookAheadToken(2); 89 if (!SecondToken.is(tok::colon) || !areTokensAdjacent(Next, SecondToken)) 90 return; 91 92 TemplateTy Template; 93 UnqualifiedId TemplateName; 94 TemplateName.setIdentifier(&II, Tok.getLocation()); 95 bool MemberOfUnknownSpecialization; 96 if (!Actions.isTemplateName(getCurScope(), SS, /*hasTemplateKeyword=*/false, 97 TemplateName, ObjectType, EnteringContext, 98 Template, MemberOfUnknownSpecialization)) 99 return; 100 101 FixDigraph(*this, PP, Next, SecondToken, tok::unknown, 102 /*AtDigraph*/false); 103} 104 105/// Parse global scope or nested-name-specifier if present. 106/// 107/// Parses a C++ global scope specifier ('::') or nested-name-specifier (which 108/// may be preceded by '::'). Note that this routine will not parse ::new or 109/// ::delete; it will just leave them in the token stream. 110/// 111/// '::'[opt] nested-name-specifier 112/// '::' 113/// 114/// nested-name-specifier: 115/// type-name '::' 116/// namespace-name '::' 117/// nested-name-specifier identifier '::' 118/// nested-name-specifier 'template'[opt] simple-template-id '::' 119/// 120/// 121/// \param SS the scope specifier that will be set to the parsed 122/// nested-name-specifier (or empty) 123/// 124/// \param ObjectType if this nested-name-specifier is being parsed following 125/// the "." or "->" of a member access expression, this parameter provides the 126/// type of the object whose members are being accessed. 127/// 128/// \param ObjectHadErrors if this unqualified-id occurs within a member access 129/// expression, indicates whether the original subexpressions had any errors. 130/// When true, diagnostics for missing 'template' keyword will be supressed. 131/// 132/// \param EnteringContext whether we will be entering into the context of 133/// the nested-name-specifier after parsing it. 134/// 135/// \param MayBePseudoDestructor When non-NULL, points to a flag that 136/// indicates whether this nested-name-specifier may be part of a 137/// pseudo-destructor name. In this case, the flag will be set false 138/// if we don't actually end up parsing a destructor name. Moreover, 139/// if we do end up determining that we are parsing a destructor name, 140/// the last component of the nested-name-specifier is not parsed as 141/// part of the scope specifier. 142/// 143/// \param IsTypename If \c true, this nested-name-specifier is known to be 144/// part of a type name. This is used to improve error recovery. 145/// 146/// \param LastII When non-NULL, points to an IdentifierInfo* that will be 147/// filled in with the leading identifier in the last component of the 148/// nested-name-specifier, if any. 149/// 150/// \param OnlyNamespace If true, only considers namespaces in lookup. 151/// 152/// 153/// \returns true if there was an error parsing a scope specifier 154bool Parser::ParseOptionalCXXScopeSpecifier( 155 CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors, 156 bool EnteringContext, bool *MayBePseudoDestructor, bool IsTypename, 157 IdentifierInfo **LastII, bool OnlyNamespace, bool InUsingDeclaration) { 158 assert(getLangOpts().CPlusPlus && 159 "Call sites of this function should be guarded by checking for C++"); 160 161 if (Tok.is(tok::annot_cxxscope)) { 162 assert(!LastII && "want last identifier but have already annotated scope"); 163 assert(!MayBePseudoDestructor && "unexpected annot_cxxscope"); 164 Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(), 165 Tok.getAnnotationRange(), 166 SS); 167 ConsumeAnnotationToken(); 168 return false; 169 } 170 171 // Has to happen before any "return false"s in this function. 172 bool CheckForDestructor = false; 173 if (MayBePseudoDestructor && *MayBePseudoDestructor) { 174 CheckForDestructor = true; 175 *MayBePseudoDestructor = false; 176 } 177 178 if (LastII) 179 *LastII = nullptr; 180 181 bool HasScopeSpecifier = false; 182 183 if (Tok.is(tok::coloncolon)) { 184 // ::new and ::delete aren't nested-name-specifiers. 185 tok::TokenKind NextKind = NextToken().getKind(); 186 if (NextKind == tok::kw_new || NextKind == tok::kw_delete) 187 return false; 188 189 if (NextKind == tok::l_brace) { 190 // It is invalid to have :: {, consume the scope qualifier and pretend 191 // like we never saw it. 192 Diag(ConsumeToken(), diag::err_expected) << tok::identifier; 193 } else { 194 // '::' - Global scope qualifier. 195 if (Actions.ActOnCXXGlobalScopeSpecifier(ConsumeToken(), SS)) 196 return true; 197 198 HasScopeSpecifier = true; 199 } 200 } 201 202 if (Tok.is(tok::kw___super)) { 203 SourceLocation SuperLoc = ConsumeToken(); 204 if (!Tok.is(tok::coloncolon)) { 205 Diag(Tok.getLocation(), diag::err_expected_coloncolon_after_super); 206 return true; 207 } 208 209 return Actions.ActOnSuperScopeSpecifier(SuperLoc, ConsumeToken(), SS); 210 } 211 212 if (!HasScopeSpecifier && 213 Tok.isOneOf(tok::kw_decltype, tok::annot_decltype)) { 214 DeclSpec DS(AttrFactory); 215 SourceLocation DeclLoc = Tok.getLocation(); 216 SourceLocation EndLoc = ParseDecltypeSpecifier(DS); 217 218 SourceLocation CCLoc; 219 // Work around a standard defect: 'decltype(auto)::' is not a 220 // nested-name-specifier. 221 if (DS.getTypeSpecType() == DeclSpec::TST_decltype_auto || 222 !TryConsumeToken(tok::coloncolon, CCLoc)) { 223 AnnotateExistingDecltypeSpecifier(DS, DeclLoc, EndLoc); 224 return false; 225 } 226 227 if (Actions.ActOnCXXNestedNameSpecifierDecltype(SS, DS, CCLoc)) 228 SS.SetInvalid(SourceRange(DeclLoc, CCLoc)); 229 230 HasScopeSpecifier = true; 231 } 232 233 // Preferred type might change when parsing qualifiers, we need the original. 234 auto SavedType = PreferredType; 235 while (true) { 236 if (HasScopeSpecifier) { 237 if (Tok.is(tok::code_completion)) { 238 cutOffParsing(); 239 // Code completion for a nested-name-specifier, where the code 240 // completion token follows the '::'. 241 Actions.CodeCompleteQualifiedId(getCurScope(), SS, EnteringContext, 242 InUsingDeclaration, ObjectType.get(), 243 SavedType.get(SS.getBeginLoc())); 244 // Include code completion token into the range of the scope otherwise 245 // when we try to annotate the scope tokens the dangling code completion 246 // token will cause assertion in 247 // Preprocessor::AnnotatePreviousCachedTokens. 248 SS.setEndLoc(Tok.getLocation()); 249 return true; 250 } 251 252 // C++ [basic.lookup.classref]p5: 253 // If the qualified-id has the form 254 // 255 // ::class-name-or-namespace-name::... 256 // 257 // the class-name-or-namespace-name is looked up in global scope as a 258 // class-name or namespace-name. 259 // 260 // To implement this, we clear out the object type as soon as we've 261 // seen a leading '::' or part of a nested-name-specifier. 262 ObjectType = nullptr; 263 } 264 265 // nested-name-specifier: 266 // nested-name-specifier 'template'[opt] simple-template-id '::' 267 268 // Parse the optional 'template' keyword, then make sure we have 269 // 'identifier <' after it. 270 if (Tok.is(tok::kw_template)) { 271 // If we don't have a scope specifier or an object type, this isn't a 272 // nested-name-specifier, since they aren't allowed to start with 273 // 'template'. 274 if (!HasScopeSpecifier && !ObjectType) 275 break; 276 277 TentativeParsingAction TPA(*this); 278 SourceLocation TemplateKWLoc = ConsumeToken(); 279 280 UnqualifiedId TemplateName; 281 if (Tok.is(tok::identifier)) { 282 // Consume the identifier. 283 TemplateName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation()); 284 ConsumeToken(); 285 } else if (Tok.is(tok::kw_operator)) { 286 // We don't need to actually parse the unqualified-id in this case, 287 // because a simple-template-id cannot start with 'operator', but 288 // go ahead and parse it anyway for consistency with the case where 289 // we already annotated the template-id. 290 if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, 291 TemplateName)) { 292 TPA.Commit(); 293 break; 294 } 295 296 if (TemplateName.getKind() != UnqualifiedIdKind::IK_OperatorFunctionId && 297 TemplateName.getKind() != UnqualifiedIdKind::IK_LiteralOperatorId) { 298 Diag(TemplateName.getSourceRange().getBegin(), 299 diag::err_id_after_template_in_nested_name_spec) 300 << TemplateName.getSourceRange(); 301 TPA.Commit(); 302 break; 303 } 304 } else { 305 TPA.Revert(); 306 break; 307 } 308 309 // If the next token is not '<', we have a qualified-id that refers 310 // to a template name, such as T::template apply, but is not a 311 // template-id. 312 if (Tok.isNot(tok::less)) { 313 TPA.Revert(); 314 break; 315 } 316 317 // Commit to parsing the template-id. 318 TPA.Commit(); 319 TemplateTy Template; 320 TemplateNameKind TNK = Actions.ActOnTemplateName( 321 getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType, 322 EnteringContext, Template, /*AllowInjectedClassName*/ true); 323 if (AnnotateTemplateIdToken(Template, TNK, SS, TemplateKWLoc, 324 TemplateName, false)) 325 return true; 326 327 continue; 328 } 329 330 if (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) { 331 // We have 332 // 333 // template-id '::' 334 // 335 // So we need to check whether the template-id is a simple-template-id of 336 // the right kind (it should name a type or be dependent), and then 337 // convert it into a type within the nested-name-specifier. 338 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); 339 if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) { 340 *MayBePseudoDestructor = true; 341 return false; 342 } 343 344 if (LastII) 345 *LastII = TemplateId->Name; 346 347 // Consume the template-id token. 348 ConsumeAnnotationToken(); 349 350 assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!"); 351 SourceLocation CCLoc = ConsumeToken(); 352 353 HasScopeSpecifier = true; 354 355 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(), 356 TemplateId->NumArgs); 357 358 if (TemplateId->isInvalid() || 359 Actions.ActOnCXXNestedNameSpecifier(getCurScope(), 360 SS, 361 TemplateId->TemplateKWLoc, 362 TemplateId->Template, 363 TemplateId->TemplateNameLoc, 364 TemplateId->LAngleLoc, 365 TemplateArgsPtr, 366 TemplateId->RAngleLoc, 367 CCLoc, 368 EnteringContext)) { 369 SourceLocation StartLoc 370 = SS.getBeginLoc().isValid()? SS.getBeginLoc() 371 : TemplateId->TemplateNameLoc; 372 SS.SetInvalid(SourceRange(StartLoc, CCLoc)); 373 } 374 375 continue; 376 } 377 378 // The rest of the nested-name-specifier possibilities start with 379 // tok::identifier. 380 if (Tok.isNot(tok::identifier)) 381 break; 382 383 IdentifierInfo &II = *Tok.getIdentifierInfo(); 384 385 // nested-name-specifier: 386 // type-name '::' 387 // namespace-name '::' 388 // nested-name-specifier identifier '::' 389 Token Next = NextToken(); 390 Sema::NestedNameSpecInfo IdInfo(&II, Tok.getLocation(), Next.getLocation(), 391 ObjectType); 392 393 // If we get foo:bar, this is almost certainly a typo for foo::bar. Recover 394 // and emit a fixit hint for it. 395 if (Next.is(tok::colon) && !ColonIsSacred) { 396 if (Actions.IsInvalidUnlessNestedName(getCurScope(), SS, IdInfo, 397 EnteringContext) && 398 // If the token after the colon isn't an identifier, it's still an 399 // error, but they probably meant something else strange so don't 400 // recover like this. 401 PP.LookAhead(1).is(tok::identifier)) { 402 Diag(Next, diag::err_unexpected_colon_in_nested_name_spec) 403 << FixItHint::CreateReplacement(Next.getLocation(), "::"); 404 // Recover as if the user wrote '::'. 405 Next.setKind(tok::coloncolon); 406 } 407 } 408 409 if (Next.is(tok::coloncolon) && GetLookAheadToken(2).is(tok::l_brace)) { 410 // It is invalid to have :: {, consume the scope qualifier and pretend 411 // like we never saw it. 412 Token Identifier = Tok; // Stash away the identifier. 413 ConsumeToken(); // Eat the identifier, current token is now '::'. 414 Diag(PP.getLocForEndOfToken(ConsumeToken()), diag::err_expected) 415 << tok::identifier; 416 UnconsumeToken(Identifier); // Stick the identifier back. 417 Next = NextToken(); // Point Next at the '{' token. 418 } 419 420 if (Next.is(tok::coloncolon)) { 421 if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) { 422 *MayBePseudoDestructor = true; 423 return false; 424 } 425 426 if (ColonIsSacred) { 427 const Token &Next2 = GetLookAheadToken(2); 428 if (Next2.is(tok::kw_private) || Next2.is(tok::kw_protected) || 429 Next2.is(tok::kw_public) || Next2.is(tok::kw_virtual)) { 430 Diag(Next2, diag::err_unexpected_token_in_nested_name_spec) 431 << Next2.getName() 432 << FixItHint::CreateReplacement(Next.getLocation(), ":"); 433 Token ColonColon; 434 PP.Lex(ColonColon); 435 ColonColon.setKind(tok::colon); 436 PP.EnterToken(ColonColon, /*IsReinject*/ true); 437 break; 438 } 439 } 440 441 if (LastII) 442 *LastII = &II; 443 444 // We have an identifier followed by a '::'. Lookup this name 445 // as the name in a nested-name-specifier. 446 Token Identifier = Tok; 447 SourceLocation IdLoc = ConsumeToken(); 448 assert(Tok.isOneOf(tok::coloncolon, tok::colon) && 449 "NextToken() not working properly!"); 450 Token ColonColon = Tok; 451 SourceLocation CCLoc = ConsumeToken(); 452 453 bool IsCorrectedToColon = false; 454 bool *CorrectionFlagPtr = ColonIsSacred ? &IsCorrectedToColon : nullptr; 455 if (Actions.ActOnCXXNestedNameSpecifier( 456 getCurScope(), IdInfo, EnteringContext, SS, false, 457 CorrectionFlagPtr, OnlyNamespace)) { 458 // Identifier is not recognized as a nested name, but we can have 459 // mistyped '::' instead of ':'. 460 if (CorrectionFlagPtr && IsCorrectedToColon) { 461 ColonColon.setKind(tok::colon); 462 PP.EnterToken(Tok, /*IsReinject*/ true); 463 PP.EnterToken(ColonColon, /*IsReinject*/ true); 464 Tok = Identifier; 465 break; 466 } 467 SS.SetInvalid(SourceRange(IdLoc, CCLoc)); 468 } 469 HasScopeSpecifier = true; 470 continue; 471 } 472 473 CheckForTemplateAndDigraph(Next, ObjectType, EnteringContext, II, SS); 474 475 // nested-name-specifier: 476 // type-name '<' 477 if (Next.is(tok::less)) { 478 479 TemplateTy Template; 480 UnqualifiedId TemplateName; 481 TemplateName.setIdentifier(&II, Tok.getLocation()); 482 bool MemberOfUnknownSpecialization; 483 if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS, 484 /*hasTemplateKeyword=*/false, 485 TemplateName, 486 ObjectType, 487 EnteringContext, 488 Template, 489 MemberOfUnknownSpecialization)) { 490 // If lookup didn't find anything, we treat the name as a template-name 491 // anyway. C++20 requires this, and in prior language modes it improves 492 // error recovery. But before we commit to this, check that we actually 493 // have something that looks like a template-argument-list next. 494 if (!IsTypename && TNK == TNK_Undeclared_template && 495 isTemplateArgumentList(1) == TPResult::False) 496 break; 497 498 // We have found a template name, so annotate this token 499 // with a template-id annotation. We do not permit the 500 // template-id to be translated into a type annotation, 501 // because some clients (e.g., the parsing of class template 502 // specializations) still want to see the original template-id 503 // token, and it might not be a type at all (e.g. a concept name in a 504 // type-constraint). 505 ConsumeToken(); 506 if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(), 507 TemplateName, false)) 508 return true; 509 continue; 510 } 511 512 if (MemberOfUnknownSpecialization && (ObjectType || SS.isSet()) && 513 (IsTypename || isTemplateArgumentList(1) == TPResult::True)) { 514 // If we had errors before, ObjectType can be dependent even without any 515 // templates. Do not report missing template keyword in that case. 516 if (!ObjectHadErrors) { 517 // We have something like t::getAs<T>, where getAs is a 518 // member of an unknown specialization. However, this will only 519 // parse correctly as a template, so suggest the keyword 'template' 520 // before 'getAs' and treat this as a dependent template name. 521 unsigned DiagID = diag::err_missing_dependent_template_keyword; 522 if (getLangOpts().MicrosoftExt) 523 DiagID = diag::warn_missing_dependent_template_keyword; 524 525 Diag(Tok.getLocation(), DiagID) 526 << II.getName() 527 << FixItHint::CreateInsertion(Tok.getLocation(), "template "); 528 } 529 530 SourceLocation TemplateNameLoc = ConsumeToken(); 531 532 TemplateNameKind TNK = Actions.ActOnTemplateName( 533 getCurScope(), SS, TemplateNameLoc, TemplateName, ObjectType, 534 EnteringContext, Template, /*AllowInjectedClassName*/ true); 535 if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(), 536 TemplateName, false)) 537 return true; 538 539 continue; 540 } 541 } 542 543 // We don't have any tokens that form the beginning of a 544 // nested-name-specifier, so we're done. 545 break; 546 } 547 548 // Even if we didn't see any pieces of a nested-name-specifier, we 549 // still check whether there is a tilde in this position, which 550 // indicates a potential pseudo-destructor. 551 if (CheckForDestructor && !HasScopeSpecifier && Tok.is(tok::tilde)) 552 *MayBePseudoDestructor = true; 553 554 return false; 555} 556 557ExprResult Parser::tryParseCXXIdExpression(CXXScopeSpec &SS, 558 bool isAddressOfOperand, 559 Token &Replacement) { 560 ExprResult E; 561 562 // We may have already annotated this id-expression. 563 switch (Tok.getKind()) { 564 case tok::annot_non_type: { 565 NamedDecl *ND = getNonTypeAnnotation(Tok); 566 SourceLocation Loc = ConsumeAnnotationToken(); 567 E = Actions.ActOnNameClassifiedAsNonType(getCurScope(), SS, ND, Loc, Tok); 568 break; 569 } 570 571 case tok::annot_non_type_dependent: { 572 IdentifierInfo *II = getIdentifierAnnotation(Tok); 573 SourceLocation Loc = ConsumeAnnotationToken(); 574 575 // This is only the direct operand of an & operator if it is not 576 // followed by a postfix-expression suffix. 577 if (isAddressOfOperand && isPostfixExpressionSuffixStart()) 578 isAddressOfOperand = false; 579 580 E = Actions.ActOnNameClassifiedAsDependentNonType(SS, II, Loc, 581 isAddressOfOperand); 582 break; 583 } 584 585 case tok::annot_non_type_undeclared: { 586 assert(SS.isEmpty() && 587 "undeclared non-type annotation should be unqualified"); 588 IdentifierInfo *II = getIdentifierAnnotation(Tok); 589 SourceLocation Loc = ConsumeAnnotationToken(); 590 E = Actions.ActOnNameClassifiedAsUndeclaredNonType(II, Loc); 591 break; 592 } 593 594 default: 595 SourceLocation TemplateKWLoc; 596 UnqualifiedId Name; 597 if (ParseUnqualifiedId(SS, /*ObjectType=*/nullptr, 598 /*ObjectHadErrors=*/false, 599 /*EnteringContext=*/false, 600 /*AllowDestructorName=*/false, 601 /*AllowConstructorName=*/false, 602 /*AllowDeductionGuide=*/false, &TemplateKWLoc, Name)) 603 return ExprError(); 604 605 // This is only the direct operand of an & operator if it is not 606 // followed by a postfix-expression suffix. 607 if (isAddressOfOperand && isPostfixExpressionSuffixStart()) 608 isAddressOfOperand = false; 609 610 E = Actions.ActOnIdExpression( 611 getCurScope(), SS, TemplateKWLoc, Name, Tok.is(tok::l_paren), 612 isAddressOfOperand, /*CCC=*/nullptr, /*IsInlineAsmIdentifier=*/false, 613 &Replacement); 614 break; 615 } 616 617 if (!E.isInvalid() && !E.isUnset() && Tok.is(tok::less)) 618 checkPotentialAngleBracket(E); 619 return E; 620} 621 622/// ParseCXXIdExpression - Handle id-expression. 623/// 624/// id-expression: 625/// unqualified-id 626/// qualified-id 627/// 628/// qualified-id: 629/// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id 630/// '::' identifier 631/// '::' operator-function-id 632/// '::' template-id 633/// 634/// NOTE: The standard specifies that, for qualified-id, the parser does not 635/// expect: 636/// 637/// '::' conversion-function-id 638/// '::' '~' class-name 639/// 640/// This may cause a slight inconsistency on diagnostics: 641/// 642/// class C {}; 643/// namespace A {} 644/// void f() { 645/// :: A :: ~ C(); // Some Sema error about using destructor with a 646/// // namespace. 647/// :: ~ C(); // Some Parser error like 'unexpected ~'. 648/// } 649/// 650/// We simplify the parser a bit and make it work like: 651/// 652/// qualified-id: 653/// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id 654/// '::' unqualified-id 655/// 656/// That way Sema can handle and report similar errors for namespaces and the 657/// global scope. 658/// 659/// The isAddressOfOperand parameter indicates that this id-expression is a 660/// direct operand of the address-of operator. This is, besides member contexts, 661/// the only place where a qualified-id naming a non-static class member may 662/// appear. 663/// 664ExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) { 665 // qualified-id: 666 // '::'[opt] nested-name-specifier 'template'[opt] unqualified-id 667 // '::' unqualified-id 668 // 669 CXXScopeSpec SS; 670 ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr, 671 /*ObjectHadErrors=*/false, 672 /*EnteringContext=*/false); 673 674 Token Replacement; 675 ExprResult Result = 676 tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement); 677 if (Result.isUnset()) { 678 // If the ExprResult is valid but null, then typo correction suggested a 679 // keyword replacement that needs to be reparsed. 680 UnconsumeToken(Replacement); 681 Result = tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement); 682 } 683 assert(!Result.isUnset() && "Typo correction suggested a keyword replacement " 684 "for a previous keyword suggestion"); 685 return Result; 686} 687 688/// ParseLambdaExpression - Parse a C++11 lambda expression. 689/// 690/// lambda-expression: 691/// lambda-introducer lambda-declarator compound-statement 692/// lambda-introducer '<' template-parameter-list '>' 693/// requires-clause[opt] lambda-declarator compound-statement 694/// 695/// lambda-introducer: 696/// '[' lambda-capture[opt] ']' 697/// 698/// lambda-capture: 699/// capture-default 700/// capture-list 701/// capture-default ',' capture-list 702/// 703/// capture-default: 704/// '&' 705/// '=' 706/// 707/// capture-list: 708/// capture 709/// capture-list ',' capture 710/// 711/// capture: 712/// simple-capture 713/// init-capture [C++1y] 714/// 715/// simple-capture: 716/// identifier 717/// '&' identifier 718/// 'this' 719/// 720/// init-capture: [C++1y] 721/// identifier initializer 722/// '&' identifier initializer 723/// 724/// lambda-declarator: 725/// lambda-specifiers [C++2b] 726/// '(' parameter-declaration-clause ')' lambda-specifiers 727/// requires-clause[opt] 728/// 729/// lambda-specifiers: 730/// decl-specifier-seq[opt] noexcept-specifier[opt] 731/// attribute-specifier-seq[opt] trailing-return-type[opt] 732/// 733ExprResult Parser::ParseLambdaExpression() { 734 // Parse lambda-introducer. 735 LambdaIntroducer Intro; 736 if (ParseLambdaIntroducer(Intro)) { 737 SkipUntil(tok::r_square, StopAtSemi); 738 SkipUntil(tok::l_brace, StopAtSemi); 739 SkipUntil(tok::r_brace, StopAtSemi); 740 return ExprError(); 741 } 742 743 return ParseLambdaExpressionAfterIntroducer(Intro); 744} 745 746/// Use lookahead and potentially tentative parsing to determine if we are 747/// looking at a C++11 lambda expression, and parse it if we are. 748/// 749/// If we are not looking at a lambda expression, returns ExprError(). 750ExprResult Parser::TryParseLambdaExpression() { 751 assert(getLangOpts().CPlusPlus11 752 && Tok.is(tok::l_square) 753 && "Not at the start of a possible lambda expression."); 754 755 const Token Next = NextToken(); 756 if (Next.is(tok::eof)) // Nothing else to lookup here... 757 return ExprEmpty(); 758 759 const Token After = GetLookAheadToken(2); 760 // If lookahead indicates this is a lambda... 761 if (Next.is(tok::r_square) || // [] 762 Next.is(tok::equal) || // [= 763 (Next.is(tok::amp) && // [&] or [&, 764 After.isOneOf(tok::r_square, tok::comma)) || 765 (Next.is(tok::identifier) && // [identifier] 766 After.is(tok::r_square)) || 767 Next.is(tok::ellipsis)) { // [... 768 return ParseLambdaExpression(); 769 } 770 771 // If lookahead indicates an ObjC message send... 772 // [identifier identifier 773 if (Next.is(tok::identifier) && After.is(tok::identifier)) 774 return ExprEmpty(); 775 776 // Here, we're stuck: lambda introducers and Objective-C message sends are 777 // unambiguous, but it requires arbitrary lookhead. [a,b,c,d,e,f,g] is a 778 // lambda, and [a,b,c,d,e,f,g h] is a Objective-C message send. Instead of 779 // writing two routines to parse a lambda introducer, just try to parse 780 // a lambda introducer first, and fall back if that fails. 781 LambdaIntroducer Intro; 782 { 783 TentativeParsingAction TPA(*this); 784 LambdaIntroducerTentativeParse Tentative; 785 if (ParseLambdaIntroducer(Intro, &Tentative)) { 786 TPA.Commit(); 787 return ExprError(); 788 } 789 790 switch (Tentative) { 791 case LambdaIntroducerTentativeParse::Success: 792 TPA.Commit(); 793 break; 794 795 case LambdaIntroducerTentativeParse::Incomplete: 796 // Didn't fully parse the lambda-introducer, try again with a 797 // non-tentative parse. 798 TPA.Revert(); 799 Intro = LambdaIntroducer(); 800 if (ParseLambdaIntroducer(Intro)) 801 return ExprError(); 802 break; 803 804 case LambdaIntroducerTentativeParse::MessageSend: 805 case LambdaIntroducerTentativeParse::Invalid: 806 // Not a lambda-introducer, might be a message send. 807 TPA.Revert(); 808 return ExprEmpty(); 809 } 810 } 811 812 return ParseLambdaExpressionAfterIntroducer(Intro); 813} 814 815/// Parse a lambda introducer. 816/// \param Intro A LambdaIntroducer filled in with information about the 817/// contents of the lambda-introducer. 818/// \param Tentative If non-null, we are disambiguating between a 819/// lambda-introducer and some other construct. In this mode, we do not 820/// produce any diagnostics or take any other irreversible action unless 821/// we're sure that this is a lambda-expression. 822/// \return \c true if parsing (or disambiguation) failed with a diagnostic and 823/// the caller should bail out / recover. 824bool Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro, 825 LambdaIntroducerTentativeParse *Tentative) { 826 if (Tentative) 827 *Tentative = LambdaIntroducerTentativeParse::Success; 828 829 assert(Tok.is(tok::l_square) && "Lambda expressions begin with '['."); 830 BalancedDelimiterTracker T(*this, tok::l_square); 831 T.consumeOpen(); 832 833 Intro.Range.setBegin(T.getOpenLocation()); 834 835 bool First = true; 836 837 // Produce a diagnostic if we're not tentatively parsing; otherwise track 838 // that our parse has failed. 839 auto Invalid = [&](llvm::function_ref<void()> Action) { 840 if (Tentative) { 841 *Tentative = LambdaIntroducerTentativeParse::Invalid; 842 return false; 843 } 844 Action(); 845 return true; 846 }; 847 848 // Perform some irreversible action if this is a non-tentative parse; 849 // otherwise note that our actions were incomplete. 850 auto NonTentativeAction = [&](llvm::function_ref<void()> Action) { 851 if (Tentative) 852 *Tentative = LambdaIntroducerTentativeParse::Incomplete; 853 else 854 Action(); 855 }; 856 857 // Parse capture-default. 858 if (Tok.is(tok::amp) && 859 (NextToken().is(tok::comma) || NextToken().is(tok::r_square))) { 860 Intro.Default = LCD_ByRef; 861 Intro.DefaultLoc = ConsumeToken(); 862 First = false; 863 if (!Tok.getIdentifierInfo()) { 864 // This can only be a lambda; no need for tentative parsing any more. 865 // '[[and]]' can still be an attribute, though. 866 Tentative = nullptr; 867 } 868 } else if (Tok.is(tok::equal)) { 869 Intro.Default = LCD_ByCopy; 870 Intro.DefaultLoc = ConsumeToken(); 871 First = false; 872 Tentative = nullptr; 873 } 874 875 while (Tok.isNot(tok::r_square)) { 876 if (!First) { 877 if (Tok.isNot(tok::comma)) { 878 // Provide a completion for a lambda introducer here. Except 879 // in Objective-C, where this is Almost Surely meant to be a message 880 // send. In that case, fail here and let the ObjC message 881 // expression parser perform the completion. 882 if (Tok.is(tok::code_completion) && 883 !(getLangOpts().ObjC && Tentative)) { 884 cutOffParsing(); 885 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro, 886 /*AfterAmpersand=*/false); 887 break; 888 } 889 890 return Invalid([&] { 891 Diag(Tok.getLocation(), diag::err_expected_comma_or_rsquare); 892 }); 893 } 894 ConsumeToken(); 895 } 896 897 if (Tok.is(tok::code_completion)) { 898 cutOffParsing(); 899 // If we're in Objective-C++ and we have a bare '[', then this is more 900 // likely to be a message receiver. 901 if (getLangOpts().ObjC && Tentative && First) 902 Actions.CodeCompleteObjCMessageReceiver(getCurScope()); 903 else 904 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro, 905 /*AfterAmpersand=*/false); 906 break; 907 } 908 909 First = false; 910 911 // Parse capture. 912 LambdaCaptureKind Kind = LCK_ByCopy; 913 LambdaCaptureInitKind InitKind = LambdaCaptureInitKind::NoInit; 914 SourceLocation Loc; 915 IdentifierInfo *Id = nullptr; 916 SourceLocation EllipsisLocs[4]; 917 ExprResult Init; 918 SourceLocation LocStart = Tok.getLocation(); 919 920 if (Tok.is(tok::star)) { 921 Loc = ConsumeToken(); 922 if (Tok.is(tok::kw_this)) { 923 ConsumeToken(); 924 Kind = LCK_StarThis; 925 } else { 926 return Invalid([&] { 927 Diag(Tok.getLocation(), diag::err_expected_star_this_capture); 928 }); 929 } 930 } else if (Tok.is(tok::kw_this)) { 931 Kind = LCK_This; 932 Loc = ConsumeToken(); 933 } else if (Tok.isOneOf(tok::amp, tok::equal) && 934 NextToken().isOneOf(tok::comma, tok::r_square) && 935 Intro.Default == LCD_None) { 936 // We have a lone "&" or "=" which is either a misplaced capture-default 937 // or the start of a capture (in the "&" case) with the rest of the 938 // capture missing. Both are an error but a misplaced capture-default 939 // is more likely if we don't already have a capture default. 940 return Invalid( 941 [&] { Diag(Tok.getLocation(), diag::err_capture_default_first); }); 942 } else { 943 TryConsumeToken(tok::ellipsis, EllipsisLocs[0]); 944 945 if (Tok.is(tok::amp)) { 946 Kind = LCK_ByRef; 947 ConsumeToken(); 948 949 if (Tok.is(tok::code_completion)) { 950 cutOffParsing(); 951 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro, 952 /*AfterAmpersand=*/true); 953 break; 954 } 955 } 956 957 TryConsumeToken(tok::ellipsis, EllipsisLocs[1]); 958 959 if (Tok.is(tok::identifier)) { 960 Id = Tok.getIdentifierInfo(); 961 Loc = ConsumeToken(); 962 } else if (Tok.is(tok::kw_this)) { 963 return Invalid([&] { 964 // FIXME: Suggest a fixit here. 965 Diag(Tok.getLocation(), diag::err_this_captured_by_reference); 966 }); 967 } else { 968 return Invalid([&] { 969 Diag(Tok.getLocation(), diag::err_expected_capture); 970 }); 971 } 972 973 TryConsumeToken(tok::ellipsis, EllipsisLocs[2]); 974 975 if (Tok.is(tok::l_paren)) { 976 BalancedDelimiterTracker Parens(*this, tok::l_paren); 977 Parens.consumeOpen(); 978 979 InitKind = LambdaCaptureInitKind::DirectInit; 980 981 ExprVector Exprs; 982 CommaLocsTy Commas; 983 if (Tentative) { 984 Parens.skipToEnd(); 985 *Tentative = LambdaIntroducerTentativeParse::Incomplete; 986 } else if (ParseExpressionList(Exprs, Commas)) { 987 Parens.skipToEnd(); 988 Init = ExprError(); 989 } else { 990 Parens.consumeClose(); 991 Init = Actions.ActOnParenListExpr(Parens.getOpenLocation(), 992 Parens.getCloseLocation(), 993 Exprs); 994 } 995 } else if (Tok.isOneOf(tok::l_brace, tok::equal)) { 996 // Each lambda init-capture forms its own full expression, which clears 997 // Actions.MaybeODRUseExprs. So create an expression evaluation context 998 // to save the necessary state, and restore it later. 999 EnterExpressionEvaluationContext EC( 1000 Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluated); 1001 1002 if (TryConsumeToken(tok::equal)) 1003 InitKind = LambdaCaptureInitKind::CopyInit; 1004 else 1005 InitKind = LambdaCaptureInitKind::ListInit; 1006 1007 if (!Tentative) { 1008 Init = ParseInitializer(); 1009 } else if (Tok.is(tok::l_brace)) { 1010 BalancedDelimiterTracker Braces(*this, tok::l_brace); 1011 Braces.consumeOpen(); 1012 Braces.skipToEnd(); 1013 *Tentative = LambdaIntroducerTentativeParse::Incomplete; 1014 } else { 1015 // We're disambiguating this: 1016 // 1017 // [..., x = expr 1018 // 1019 // We need to find the end of the following expression in order to 1020 // determine whether this is an Obj-C message send's receiver, a 1021 // C99 designator, or a lambda init-capture. 1022 // 1023 // Parse the expression to find where it ends, and annotate it back 1024 // onto the tokens. We would have parsed this expression the same way 1025 // in either case: both the RHS of an init-capture and the RHS of an 1026 // assignment expression are parsed as an initializer-clause, and in 1027 // neither case can anything be added to the scope between the '[' and 1028 // here. 1029 // 1030 // FIXME: This is horrible. Adding a mechanism to skip an expression 1031 // would be much cleaner. 1032 // FIXME: If there is a ',' before the next ']' or ':', we can skip to 1033 // that instead. (And if we see a ':' with no matching '?', we can 1034 // classify this as an Obj-C message send.) 1035 SourceLocation StartLoc = Tok.getLocation(); 1036 InMessageExpressionRAIIObject MaybeInMessageExpression(*this, true); 1037 Init = ParseInitializer(); 1038 if (!Init.isInvalid()) 1039 Init = Actions.CorrectDelayedTyposInExpr(Init.get()); 1040 1041 if (Tok.getLocation() != StartLoc) { 1042 // Back out the lexing of the token after the initializer. 1043 PP.RevertCachedTokens(1); 1044 1045 // Replace the consumed tokens with an appropriate annotation. 1046 Tok.setLocation(StartLoc); 1047 Tok.setKind(tok::annot_primary_expr); 1048 setExprAnnotation(Tok, Init); 1049 Tok.setAnnotationEndLoc(PP.getLastCachedTokenLocation()); 1050 PP.AnnotateCachedTokens(Tok); 1051 1052 // Consume the annotated initializer. 1053 ConsumeAnnotationToken(); 1054 } 1055 } 1056 } 1057 1058 TryConsumeToken(tok::ellipsis, EllipsisLocs[3]); 1059 } 1060 1061 // Check if this is a message send before we act on a possible init-capture. 1062 if (Tentative && Tok.is(tok::identifier) && 1063 NextToken().isOneOf(tok::colon, tok::r_square)) { 1064 // This can only be a message send. We're done with disambiguation. 1065 *Tentative = LambdaIntroducerTentativeParse::MessageSend; 1066 return false; 1067 } 1068 1069 // Ensure that any ellipsis was in the right place. 1070 SourceLocation EllipsisLoc; 1071 if (std::any_of(std::begin(EllipsisLocs), std::end(EllipsisLocs), 1072 [](SourceLocation Loc) { return Loc.isValid(); })) { 1073 // The '...' should appear before the identifier in an init-capture, and 1074 // after the identifier otherwise. 1075 bool InitCapture = InitKind != LambdaCaptureInitKind::NoInit; 1076 SourceLocation *ExpectedEllipsisLoc = 1077 !InitCapture ? &EllipsisLocs[2] : 1078 Kind == LCK_ByRef ? &EllipsisLocs[1] : 1079 &EllipsisLocs[0]; 1080 EllipsisLoc = *ExpectedEllipsisLoc; 1081 1082 unsigned DiagID = 0; 1083 if (EllipsisLoc.isInvalid()) { 1084 DiagID = diag::err_lambda_capture_misplaced_ellipsis; 1085 for (SourceLocation Loc : EllipsisLocs) { 1086 if (Loc.isValid()) 1087 EllipsisLoc = Loc; 1088 } 1089 } else { 1090 unsigned NumEllipses = std::accumulate( 1091 std::begin(EllipsisLocs), std::end(EllipsisLocs), 0, 1092 [](int N, SourceLocation Loc) { return N + Loc.isValid(); }); 1093 if (NumEllipses > 1) 1094 DiagID = diag::err_lambda_capture_multiple_ellipses; 1095 } 1096 if (DiagID) { 1097 NonTentativeAction([&] { 1098 // Point the diagnostic at the first misplaced ellipsis. 1099 SourceLocation DiagLoc; 1100 for (SourceLocation &Loc : EllipsisLocs) { 1101 if (&Loc != ExpectedEllipsisLoc && Loc.isValid()) { 1102 DiagLoc = Loc; 1103 break; 1104 } 1105 } 1106 assert(DiagLoc.isValid() && "no location for diagnostic"); 1107 1108 // Issue the diagnostic and produce fixits showing where the ellipsis 1109 // should have been written. 1110 auto &&D = Diag(DiagLoc, DiagID); 1111 if (DiagID == diag::err_lambda_capture_misplaced_ellipsis) { 1112 SourceLocation ExpectedLoc = 1113 InitCapture ? Loc 1114 : Lexer::getLocForEndOfToken( 1115 Loc, 0, PP.getSourceManager(), getLangOpts()); 1116 D << InitCapture << FixItHint::CreateInsertion(ExpectedLoc, "..."); 1117 } 1118 for (SourceLocation &Loc : EllipsisLocs) { 1119 if (&Loc != ExpectedEllipsisLoc && Loc.isValid()) 1120 D << FixItHint::CreateRemoval(Loc); 1121 } 1122 }); 1123 } 1124 } 1125 1126 // Process the init-capture initializers now rather than delaying until we 1127 // form the lambda-expression so that they can be handled in the context 1128 // enclosing the lambda-expression, rather than in the context of the 1129 // lambda-expression itself. 1130 ParsedType InitCaptureType; 1131 if (Init.isUsable()) 1132 Init = Actions.CorrectDelayedTyposInExpr(Init.get()); 1133 if (Init.isUsable()) { 1134 NonTentativeAction([&] { 1135 // Get the pointer and store it in an lvalue, so we can use it as an 1136 // out argument. 1137 Expr *InitExpr = Init.get(); 1138 // This performs any lvalue-to-rvalue conversions if necessary, which 1139 // can affect what gets captured in the containing decl-context. 1140 InitCaptureType = Actions.actOnLambdaInitCaptureInitialization( 1141 Loc, Kind == LCK_ByRef, EllipsisLoc, Id, InitKind, InitExpr); 1142 Init = InitExpr; 1143 }); 1144 } 1145 1146 SourceLocation LocEnd = PrevTokLocation; 1147 1148 Intro.addCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init, 1149 InitCaptureType, SourceRange(LocStart, LocEnd)); 1150 } 1151 1152 T.consumeClose(); 1153 Intro.Range.setEnd(T.getCloseLocation()); 1154 return false; 1155} 1156 1157static void tryConsumeLambdaSpecifierToken(Parser &P, 1158 SourceLocation &MutableLoc, 1159 SourceLocation &ConstexprLoc, 1160 SourceLocation &ConstevalLoc, 1161 SourceLocation &DeclEndLoc) { 1162 assert(MutableLoc.isInvalid()); 1163 assert(ConstexprLoc.isInvalid()); 1164 // Consume constexpr-opt mutable-opt in any sequence, and set the DeclEndLoc 1165 // to the final of those locations. Emit an error if we have multiple 1166 // copies of those keywords and recover. 1167 1168 while (true) { 1169 switch (P.getCurToken().getKind()) { 1170 case tok::kw_mutable: { 1171 if (MutableLoc.isValid()) { 1172 P.Diag(P.getCurToken().getLocation(), 1173 diag::err_lambda_decl_specifier_repeated) 1174 << 0 << FixItHint::CreateRemoval(P.getCurToken().getLocation()); 1175 } 1176 MutableLoc = P.ConsumeToken(); 1177 DeclEndLoc = MutableLoc; 1178 break /*switch*/; 1179 } 1180 case tok::kw_constexpr: 1181 if (ConstexprLoc.isValid()) { 1182 P.Diag(P.getCurToken().getLocation(), 1183 diag::err_lambda_decl_specifier_repeated) 1184 << 1 << FixItHint::CreateRemoval(P.getCurToken().getLocation()); 1185 } 1186 ConstexprLoc = P.ConsumeToken(); 1187 DeclEndLoc = ConstexprLoc; 1188 break /*switch*/; 1189 case tok::kw_consteval: 1190 if (ConstevalLoc.isValid()) { 1191 P.Diag(P.getCurToken().getLocation(), 1192 diag::err_lambda_decl_specifier_repeated) 1193 << 2 << FixItHint::CreateRemoval(P.getCurToken().getLocation()); 1194 } 1195 ConstevalLoc = P.ConsumeToken(); 1196 DeclEndLoc = ConstevalLoc; 1197 break /*switch*/; 1198 default: 1199 return; 1200 } 1201 } 1202} 1203 1204static void 1205addConstexprToLambdaDeclSpecifier(Parser &P, SourceLocation ConstexprLoc, 1206 DeclSpec &DS) { 1207 if (ConstexprLoc.isValid()) { 1208 P.Diag(ConstexprLoc, !P.getLangOpts().CPlusPlus17 1209 ? diag::ext_constexpr_on_lambda_cxx17 1210 : diag::warn_cxx14_compat_constexpr_on_lambda); 1211 const char *PrevSpec = nullptr; 1212 unsigned DiagID = 0; 1213 DS.SetConstexprSpec(ConstexprSpecKind::Constexpr, ConstexprLoc, PrevSpec, 1214 DiagID); 1215 assert(PrevSpec == nullptr && DiagID == 0 && 1216 "Constexpr cannot have been set previously!"); 1217 } 1218} 1219 1220static void addConstevalToLambdaDeclSpecifier(Parser &P, 1221 SourceLocation ConstevalLoc, 1222 DeclSpec &DS) { 1223 if (ConstevalLoc.isValid()) { 1224 P.Diag(ConstevalLoc, diag::warn_cxx20_compat_consteval); 1225 const char *PrevSpec = nullptr; 1226 unsigned DiagID = 0; 1227 DS.SetConstexprSpec(ConstexprSpecKind::Consteval, ConstevalLoc, PrevSpec, 1228 DiagID); 1229 if (DiagID != 0) 1230 P.Diag(ConstevalLoc, DiagID) << PrevSpec; 1231 } 1232} 1233 1234/// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda 1235/// expression. 1236ExprResult Parser::ParseLambdaExpressionAfterIntroducer( 1237 LambdaIntroducer &Intro) { 1238 SourceLocation LambdaBeginLoc = Intro.Range.getBegin(); 1239 Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda); 1240 1241 PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc, 1242 "lambda expression parsing"); 1243 1244 1245 1246 // FIXME: Call into Actions to add any init-capture declarations to the 1247 // scope while parsing the lambda-declarator and compound-statement. 1248 1249 // Parse lambda-declarator[opt]. 1250 DeclSpec DS(AttrFactory); 1251 Declarator D(DS, DeclaratorContext::LambdaExpr); 1252 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth); 1253 Actions.PushLambdaScope(); 1254 1255 ParsedAttributes Attr(AttrFactory); 1256 if (getLangOpts().CUDA) { 1257 // In CUDA code, GNU attributes are allowed to appear immediately after the 1258 // "[...]", even if there is no "(...)" before the lambda body. 1259 MaybeParseGNUAttributes(D); 1260 } 1261 1262 // Helper to emit a warning if we see a CUDA host/device/global attribute 1263 // after '(...)'. nvcc doesn't accept this. 1264 auto WarnIfHasCUDATargetAttr = [&] { 1265 if (getLangOpts().CUDA) 1266 for (const ParsedAttr &A : Attr) 1267 if (A.getKind() == ParsedAttr::AT_CUDADevice || 1268 A.getKind() == ParsedAttr::AT_CUDAHost || 1269 A.getKind() == ParsedAttr::AT_CUDAGlobal) 1270 Diag(A.getLoc(), diag::warn_cuda_attr_lambda_position) 1271 << A.getAttrName()->getName(); 1272 }; 1273 1274 MultiParseScope TemplateParamScope(*this); 1275 if (Tok.is(tok::less)) { 1276 Diag(Tok, getLangOpts().CPlusPlus20 1277 ? diag::warn_cxx17_compat_lambda_template_parameter_list 1278 : diag::ext_lambda_template_parameter_list); 1279 1280 SmallVector<NamedDecl*, 4> TemplateParams; 1281 SourceLocation LAngleLoc, RAngleLoc; 1282 if (ParseTemplateParameters(TemplateParamScope, 1283 CurTemplateDepthTracker.getDepth(), 1284 TemplateParams, LAngleLoc, RAngleLoc)) { 1285 Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope()); 1286 return ExprError(); 1287 } 1288 1289 if (TemplateParams.empty()) { 1290 Diag(RAngleLoc, 1291 diag::err_lambda_template_parameter_list_empty); 1292 } else { 1293 ExprResult RequiresClause; 1294 if (TryConsumeToken(tok::kw_requires)) { 1295 RequiresClause = 1296 Actions.ActOnRequiresClause(ParseConstraintLogicalOrExpression( 1297 /*IsTrailingRequiresClause=*/false)); 1298 if (RequiresClause.isInvalid()) 1299 SkipUntil({tok::l_brace, tok::l_paren}, StopAtSemi | StopBeforeMatch); 1300 } 1301 1302 Actions.ActOnLambdaExplicitTemplateParameterList( 1303 LAngleLoc, TemplateParams, RAngleLoc, RequiresClause); 1304 ++CurTemplateDepthTracker; 1305 } 1306 } 1307 1308 // Implement WG21 P2173, which allows attributes immediately before the 1309 // lambda declarator and applies them to the corresponding function operator 1310 // or operator template declaration. We accept this as a conforming extension 1311 // in all language modes that support lambdas. 1312 if (isCXX11AttributeSpecifier()) { 1313 Diag(Tok, getLangOpts().CPlusPlus2b 1314 ? diag::warn_cxx20_compat_decl_attrs_on_lambda 1315 : diag::ext_decl_attrs_on_lambda); 1316 MaybeParseCXX11Attributes(D); 1317 } 1318 1319 TypeResult TrailingReturnType; 1320 SourceLocation TrailingReturnTypeLoc; 1321 1322 auto ParseLambdaSpecifiers = 1323 [&](SourceLocation LParenLoc, SourceLocation RParenLoc, 1324 MutableArrayRef<DeclaratorChunk::ParamInfo> ParamInfo, 1325 SourceLocation EllipsisLoc) { 1326 SourceLocation DeclEndLoc = RParenLoc; 1327 1328 // GNU-style attributes must be parsed before the mutable specifier to 1329 // be compatible with GCC. MSVC-style attributes must be parsed before 1330 // the mutable specifier to be compatible with MSVC. 1331 MaybeParseAttributes(PAKM_GNU | PAKM_Declspec, Attr); 1332 1333 // Parse mutable-opt and/or constexpr-opt or consteval-opt, and update 1334 // the DeclEndLoc. 1335 SourceLocation MutableLoc; 1336 SourceLocation ConstexprLoc; 1337 SourceLocation ConstevalLoc; 1338 tryConsumeLambdaSpecifierToken(*this, MutableLoc, ConstexprLoc, 1339 ConstevalLoc, DeclEndLoc); 1340 1341 addConstexprToLambdaDeclSpecifier(*this, ConstexprLoc, DS); 1342 addConstevalToLambdaDeclSpecifier(*this, ConstevalLoc, DS); 1343 // Parse exception-specification[opt]. 1344 ExceptionSpecificationType ESpecType = EST_None; 1345 SourceRange ESpecRange; 1346 SmallVector<ParsedType, 2> DynamicExceptions; 1347 SmallVector<SourceRange, 2> DynamicExceptionRanges; 1348 ExprResult NoexceptExpr; 1349 CachedTokens *ExceptionSpecTokens; 1350 ESpecType = tryParseExceptionSpecification( 1351 /*Delayed=*/false, ESpecRange, DynamicExceptions, 1352 DynamicExceptionRanges, NoexceptExpr, ExceptionSpecTokens); 1353 1354 if (ESpecType != EST_None) 1355 DeclEndLoc = ESpecRange.getEnd(); 1356 1357 // Parse attribute-specifier[opt]. 1358 MaybeParseCXX11Attributes(Attr, &DeclEndLoc); 1359 1360 // Parse OpenCL addr space attribute. 1361 if (Tok.isOneOf(tok::kw___private, tok::kw___global, tok::kw___local, 1362 tok::kw___constant, tok::kw___generic)) { 1363 ParseOpenCLQualifiers(DS.getAttributes()); 1364 ConsumeToken(); 1365 } 1366 1367 SourceLocation FunLocalRangeEnd = DeclEndLoc; 1368 1369 // Parse trailing-return-type[opt]. 1370 if (Tok.is(tok::arrow)) { 1371 FunLocalRangeEnd = Tok.getLocation(); 1372 SourceRange Range; 1373 TrailingReturnType = ParseTrailingReturnType( 1374 Range, /*MayBeFollowedByDirectInit*/ false); 1375 TrailingReturnTypeLoc = Range.getBegin(); 1376 if (Range.getEnd().isValid()) 1377 DeclEndLoc = Range.getEnd(); 1378 } 1379 1380 SourceLocation NoLoc; 1381 D.AddTypeInfo( 1382 DeclaratorChunk::getFunction( 1383 /*HasProto=*/true, 1384 /*IsAmbiguous=*/false, LParenLoc, ParamInfo.data(), 1385 ParamInfo.size(), EllipsisLoc, RParenLoc, 1386 /*RefQualifierIsLvalueRef=*/true, 1387 /*RefQualifierLoc=*/NoLoc, MutableLoc, ESpecType, ESpecRange, 1388 DynamicExceptions.data(), DynamicExceptionRanges.data(), 1389 DynamicExceptions.size(), 1390 NoexceptExpr.isUsable() ? NoexceptExpr.get() : nullptr, 1391 /*ExceptionSpecTokens*/ nullptr, 1392 /*DeclsInPrototype=*/None, LParenLoc, FunLocalRangeEnd, D, 1393 TrailingReturnType, TrailingReturnTypeLoc, &DS), 1394 std::move(Attr), DeclEndLoc); 1395 }; 1396 1397 if (Tok.is(tok::l_paren)) { 1398 ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope | 1399 Scope::FunctionDeclarationScope | 1400 Scope::DeclScope); 1401 1402 BalancedDelimiterTracker T(*this, tok::l_paren); 1403 T.consumeOpen(); 1404 SourceLocation LParenLoc = T.getOpenLocation(); 1405 1406 // Parse parameter-declaration-clause. 1407 SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo; 1408 SourceLocation EllipsisLoc; 1409 1410 if (Tok.isNot(tok::r_paren)) { 1411 Actions.RecordParsingTemplateParameterDepth( 1412 CurTemplateDepthTracker.getOriginalDepth()); 1413 1414 ParseParameterDeclarationClause(D.getContext(), Attr, ParamInfo, 1415 EllipsisLoc); 1416 // For a generic lambda, each 'auto' within the parameter declaration 1417 // clause creates a template type parameter, so increment the depth. 1418 // If we've parsed any explicit template parameters, then the depth will 1419 // have already been incremented. So we make sure that at most a single 1420 // depth level is added. 1421 if (Actions.getCurGenericLambda()) 1422 CurTemplateDepthTracker.setAddedDepth(1); 1423 } 1424 1425 T.consumeClose(); 1426 1427 // Parse lambda-specifiers. 1428 ParseLambdaSpecifiers(LParenLoc, /*DeclEndLoc=*/T.getCloseLocation(), 1429 ParamInfo, EllipsisLoc); 1430 1431 // Parse requires-clause[opt]. 1432 if (Tok.is(tok::kw_requires)) 1433 ParseTrailingRequiresClause(D); 1434 } else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute, 1435 tok::kw_constexpr, tok::kw_consteval, 1436 tok::kw___private, tok::kw___global, tok::kw___local, 1437 tok::kw___constant, tok::kw___generic, 1438 tok::kw_requires, tok::kw_noexcept) || 1439 (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) { 1440 if (!getLangOpts().CPlusPlus2b) 1441 // It's common to forget that one needs '()' before 'mutable', an 1442 // attribute specifier, the result type, or the requires clause. Deal with 1443 // this. 1444 Diag(Tok, diag::ext_lambda_missing_parens) 1445 << FixItHint::CreateInsertion(Tok.getLocation(), "() "); 1446 1447 SourceLocation NoLoc; 1448 // Parse lambda-specifiers. 1449 std::vector<DeclaratorChunk::ParamInfo> EmptyParamInfo; 1450 ParseLambdaSpecifiers(/*LParenLoc=*/NoLoc, /*RParenLoc=*/NoLoc, 1451 EmptyParamInfo, /*EllipsisLoc=*/NoLoc); 1452 } 1453 1454 WarnIfHasCUDATargetAttr(); 1455 1456 // FIXME: Rename BlockScope -> ClosureScope if we decide to continue using 1457 // it. 1458 unsigned ScopeFlags = Scope::BlockScope | Scope::FnScope | Scope::DeclScope | 1459 Scope::CompoundStmtScope; 1460 ParseScope BodyScope(this, ScopeFlags); 1461 1462 Actions.ActOnStartOfLambdaDefinition(Intro, D, getCurScope()); 1463 1464 // Parse compound-statement. 1465 if (!Tok.is(tok::l_brace)) { 1466 Diag(Tok, diag::err_expected_lambda_body); 1467 Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope()); 1468 return ExprError(); 1469 } 1470 1471 StmtResult Stmt(ParseCompoundStatementBody()); 1472 BodyScope.Exit(); 1473 TemplateParamScope.Exit(); 1474 1475 if (!Stmt.isInvalid() && !TrailingReturnType.isInvalid()) 1476 return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.get(), getCurScope()); 1477 1478 Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope()); 1479 return ExprError(); 1480} 1481 1482/// ParseCXXCasts - This handles the various ways to cast expressions to another 1483/// type. 1484/// 1485/// postfix-expression: [C++ 5.2p1] 1486/// 'dynamic_cast' '<' type-name '>' '(' expression ')' 1487/// 'static_cast' '<' type-name '>' '(' expression ')' 1488/// 'reinterpret_cast' '<' type-name '>' '(' expression ')' 1489/// 'const_cast' '<' type-name '>' '(' expression ')' 1490/// 1491/// C++ for OpenCL s2.3.1 adds: 1492/// 'addrspace_cast' '<' type-name '>' '(' expression ')' 1493ExprResult Parser::ParseCXXCasts() { 1494 tok::TokenKind Kind = Tok.getKind(); 1495 const char *CastName = nullptr; // For error messages 1496 1497 switch (Kind) { 1498 default: llvm_unreachable("Unknown C++ cast!"); 1499 case tok::kw_addrspace_cast: CastName = "addrspace_cast"; break; 1500 case tok::kw_const_cast: CastName = "const_cast"; break; 1501 case tok::kw_dynamic_cast: CastName = "dynamic_cast"; break; 1502 case tok::kw_reinterpret_cast: CastName = "reinterpret_cast"; break; 1503 case tok::kw_static_cast: CastName = "static_cast"; break; 1504 } 1505 1506 SourceLocation OpLoc = ConsumeToken(); 1507 SourceLocation LAngleBracketLoc = Tok.getLocation(); 1508 1509 // Check for "<::" which is parsed as "[:". If found, fix token stream, 1510 // diagnose error, suggest fix, and recover parsing. 1511 if (Tok.is(tok::l_square) && Tok.getLength() == 2) { 1512 Token Next = NextToken(); 1513 if (Next.is(tok::colon) && areTokensAdjacent(Tok, Next)) 1514 FixDigraph(*this, PP, Tok, Next, Kind, /*AtDigraph*/true); 1515 } 1516 1517 if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName)) 1518 return ExprError(); 1519 1520 // Parse the common declaration-specifiers piece. 1521 DeclSpec DS(AttrFactory); 1522 ParseSpecifierQualifierList(DS); 1523 1524 // Parse the abstract-declarator, if present. 1525 Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName); 1526 ParseDeclarator(DeclaratorInfo); 1527 1528 SourceLocation RAngleBracketLoc = Tok.getLocation(); 1529 1530 if (ExpectAndConsume(tok::greater)) 1531 return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << tok::less); 1532 1533 BalancedDelimiterTracker T(*this, tok::l_paren); 1534 1535 if (T.expectAndConsume(diag::err_expected_lparen_after, CastName)) 1536 return ExprError(); 1537 1538 ExprResult Result = ParseExpression(); 1539 1540 // Match the ')'. 1541 T.consumeClose(); 1542 1543 if (!Result.isInvalid() && !DeclaratorInfo.isInvalidType()) 1544 Result = Actions.ActOnCXXNamedCast(OpLoc, Kind, 1545 LAngleBracketLoc, DeclaratorInfo, 1546 RAngleBracketLoc, 1547 T.getOpenLocation(), Result.get(), 1548 T.getCloseLocation()); 1549 1550 return Result; 1551} 1552 1553/// ParseCXXTypeid - This handles the C++ typeid expression. 1554/// 1555/// postfix-expression: [C++ 5.2p1] 1556/// 'typeid' '(' expression ')' 1557/// 'typeid' '(' type-id ')' 1558/// 1559ExprResult Parser::ParseCXXTypeid() { 1560 assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!"); 1561 1562 SourceLocation OpLoc = ConsumeToken(); 1563 SourceLocation LParenLoc, RParenLoc; 1564 BalancedDelimiterTracker T(*this, tok::l_paren); 1565 1566 // typeid expressions are always parenthesized. 1567 if (T.expectAndConsume(diag::err_expected_lparen_after, "typeid")) 1568 return ExprError(); 1569 LParenLoc = T.getOpenLocation(); 1570 1571 ExprResult Result; 1572 1573 // C++0x [expr.typeid]p3: 1574 // When typeid is applied to an expression other than an lvalue of a 1575 // polymorphic class type [...] The expression is an unevaluated 1576 // operand (Clause 5). 1577 // 1578 // Note that we can't tell whether the expression is an lvalue of a 1579 // polymorphic class type until after we've parsed the expression; we 1580 // speculatively assume the subexpression is unevaluated, and fix it up 1581 // later. 1582 // 1583 // We enter the unevaluated context before trying to determine whether we 1584 // have a type-id, because the tentative parse logic will try to resolve 1585 // names, and must treat them as unevaluated. 1586 EnterExpressionEvaluationContext Unevaluated( 1587 Actions, Sema::ExpressionEvaluationContext::Unevaluated, 1588 Sema::ReuseLambdaContextDecl); 1589 1590 if (isTypeIdInParens()) { 1591 TypeResult Ty = ParseTypeName(); 1592 1593 // Match the ')'. 1594 T.consumeClose(); 1595 RParenLoc = T.getCloseLocation(); 1596 if (Ty.isInvalid() || RParenLoc.isInvalid()) 1597 return ExprError(); 1598 1599 Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/true, 1600 Ty.get().getAsOpaquePtr(), RParenLoc); 1601 } else { 1602 Result = ParseExpression(); 1603 1604 // Match the ')'. 1605 if (Result.isInvalid()) 1606 SkipUntil(tok::r_paren, StopAtSemi); 1607 else { 1608 T.consumeClose(); 1609 RParenLoc = T.getCloseLocation(); 1610 if (RParenLoc.isInvalid()) 1611 return ExprError(); 1612 1613 Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/false, 1614 Result.get(), RParenLoc); 1615 } 1616 } 1617 1618 return Result; 1619} 1620 1621/// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression. 1622/// 1623/// '__uuidof' '(' expression ')' 1624/// '__uuidof' '(' type-id ')' 1625/// 1626ExprResult Parser::ParseCXXUuidof() { 1627 assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!"); 1628 1629 SourceLocation OpLoc = ConsumeToken(); 1630 BalancedDelimiterTracker T(*this, tok::l_paren); 1631 1632 // __uuidof expressions are always parenthesized. 1633 if (T.expectAndConsume(diag::err_expected_lparen_after, "__uuidof")) 1634 return ExprError(); 1635 1636 ExprResult Result; 1637 1638 if (isTypeIdInParens()) { 1639 TypeResult Ty = ParseTypeName(); 1640 1641 // Match the ')'. 1642 T.consumeClose(); 1643 1644 if (Ty.isInvalid()) 1645 return ExprError(); 1646 1647 Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(), /*isType=*/true, 1648 Ty.get().getAsOpaquePtr(), 1649 T.getCloseLocation()); 1650 } else { 1651 EnterExpressionEvaluationContext Unevaluated( 1652 Actions, Sema::ExpressionEvaluationContext::Unevaluated); 1653 Result = ParseExpression(); 1654 1655 // Match the ')'. 1656 if (Result.isInvalid()) 1657 SkipUntil(tok::r_paren, StopAtSemi); 1658 else { 1659 T.consumeClose(); 1660 1661 Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(), 1662 /*isType=*/false, 1663 Result.get(), T.getCloseLocation()); 1664 } 1665 } 1666 1667 return Result; 1668} 1669 1670/// Parse a C++ pseudo-destructor expression after the base, 1671/// . or -> operator, and nested-name-specifier have already been 1672/// parsed. We're handling this fragment of the grammar: 1673/// 1674/// postfix-expression: [C++2a expr.post] 1675/// postfix-expression . template[opt] id-expression 1676/// postfix-expression -> template[opt] id-expression 1677/// 1678/// id-expression: 1679/// qualified-id 1680/// unqualified-id 1681/// 1682/// qualified-id: 1683/// nested-name-specifier template[opt] unqualified-id 1684/// 1685/// nested-name-specifier: 1686/// type-name :: 1687/// decltype-specifier :: FIXME: not implemented, but probably only 1688/// allowed in C++ grammar by accident 1689/// nested-name-specifier identifier :: 1690/// nested-name-specifier template[opt] simple-template-id :: 1691/// [...] 1692/// 1693/// unqualified-id: 1694/// ~ type-name 1695/// ~ decltype-specifier 1696/// [...] 1697/// 1698/// ... where the all but the last component of the nested-name-specifier 1699/// has already been parsed, and the base expression is not of a non-dependent 1700/// class type. 1701ExprResult 1702Parser::ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc, 1703 tok::TokenKind OpKind, 1704 CXXScopeSpec &SS, 1705 ParsedType ObjectType) { 1706 // If the last component of the (optional) nested-name-specifier is 1707 // template[opt] simple-template-id, it has already been annotated. 1708 UnqualifiedId FirstTypeName; 1709 SourceLocation CCLoc; 1710 if (Tok.is(tok::identifier)) { 1711 FirstTypeName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation()); 1712 ConsumeToken(); 1713 assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail"); 1714 CCLoc = ConsumeToken(); 1715 } else if (Tok.is(tok::annot_template_id)) { 1716 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); 1717 // FIXME: Carry on and build an AST representation for tooling. 1718 if (TemplateId->isInvalid()) 1719 return ExprError(); 1720 FirstTypeName.setTemplateId(TemplateId); 1721 ConsumeAnnotationToken(); 1722 assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail"); 1723 CCLoc = ConsumeToken(); 1724 } else { 1725 assert(SS.isEmpty() && "missing last component of nested name specifier"); 1726 FirstTypeName.setIdentifier(nullptr, SourceLocation()); 1727 } 1728 1729 // Parse the tilde. 1730 assert(Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail"); 1731 SourceLocation TildeLoc = ConsumeToken(); 1732 1733 if (Tok.is(tok::kw_decltype) && !FirstTypeName.isValid()) { 1734 DeclSpec DS(AttrFactory); 1735 ParseDecltypeSpecifier(DS); 1736 if (DS.getTypeSpecType() == TST_error) 1737 return ExprError(); 1738 return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind, 1739 TildeLoc, DS); 1740 } 1741 1742 if (!Tok.is(tok::identifier)) { 1743 Diag(Tok, diag::err_destructor_tilde_identifier); 1744 return ExprError(); 1745 } 1746 1747 // Parse the second type. 1748 UnqualifiedId SecondTypeName; 1749 IdentifierInfo *Name = Tok.getIdentifierInfo(); 1750 SourceLocation NameLoc = ConsumeToken(); 1751 SecondTypeName.setIdentifier(Name, NameLoc); 1752 1753 // If there is a '<', the second type name is a template-id. Parse 1754 // it as such. 1755 // 1756 // FIXME: This is not a context in which a '<' is assumed to start a template 1757 // argument list. This affects examples such as 1758 // void f(auto *p) { p->~X<int>(); } 1759 // ... but there's no ambiguity, and nowhere to write 'template' in such an 1760 // example, so we accept it anyway. 1761 if (Tok.is(tok::less) && 1762 ParseUnqualifiedIdTemplateId( 1763 SS, ObjectType, Base && Base->containsErrors(), SourceLocation(), 1764 Name, NameLoc, false, SecondTypeName, 1765 /*AssumeTemplateId=*/true)) 1766 return ExprError(); 1767 1768 return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind, 1769 SS, FirstTypeName, CCLoc, TildeLoc, 1770 SecondTypeName); 1771} 1772 1773/// ParseCXXBoolLiteral - This handles the C++ Boolean literals. 1774/// 1775/// boolean-literal: [C++ 2.13.5] 1776/// 'true' 1777/// 'false' 1778ExprResult Parser::ParseCXXBoolLiteral() { 1779 tok::TokenKind Kind = Tok.getKind(); 1780 return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind); 1781} 1782 1783/// ParseThrowExpression - This handles the C++ throw expression. 1784/// 1785/// throw-expression: [C++ 15] 1786/// 'throw' assignment-expression[opt] 1787ExprResult Parser::ParseThrowExpression() { 1788 assert(Tok.is(tok::kw_throw) && "Not throw!"); 1789 SourceLocation ThrowLoc = ConsumeToken(); // Eat the throw token. 1790 1791 // If the current token isn't the start of an assignment-expression, 1792 // then the expression is not present. This handles things like: 1793 // "C ? throw : (void)42", which is crazy but legal. 1794 switch (Tok.getKind()) { // FIXME: move this predicate somewhere common. 1795 case tok::semi: 1796 case tok::r_paren: 1797 case tok::r_square: 1798 case tok::r_brace: 1799 case tok::colon: 1800 case tok::comma: 1801 return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, nullptr); 1802 1803 default: 1804 ExprResult Expr(ParseAssignmentExpression()); 1805 if (Expr.isInvalid()) return Expr; 1806 return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, Expr.get()); 1807 } 1808} 1809 1810/// Parse the C++ Coroutines co_yield expression. 1811/// 1812/// co_yield-expression: 1813/// 'co_yield' assignment-expression[opt] 1814ExprResult Parser::ParseCoyieldExpression() { 1815 assert(Tok.is(tok::kw_co_yield) && "Not co_yield!"); 1816 1817 SourceLocation Loc = ConsumeToken(); 1818 ExprResult Expr = Tok.is(tok::l_brace) ? ParseBraceInitializer() 1819 : ParseAssignmentExpression(); 1820 if (!Expr.isInvalid()) 1821 Expr = Actions.ActOnCoyieldExpr(getCurScope(), Loc, Expr.get()); 1822 return Expr; 1823} 1824 1825/// ParseCXXThis - This handles the C++ 'this' pointer. 1826/// 1827/// C++ 9.3.2: In the body of a non-static member function, the keyword this is 1828/// a non-lvalue expression whose value is the address of the object for which 1829/// the function is called. 1830ExprResult Parser::ParseCXXThis() { 1831 assert(Tok.is(tok::kw_this) && "Not 'this'!"); 1832 SourceLocation ThisLoc = ConsumeToken(); 1833 return Actions.ActOnCXXThis(ThisLoc); 1834} 1835 1836/// ParseCXXTypeConstructExpression - Parse construction of a specified type. 1837/// Can be interpreted either as function-style casting ("int(x)") 1838/// or class type construction ("ClassType(x,y,z)") 1839/// or creation of a value-initialized type ("int()"). 1840/// See [C++ 5.2.3]. 1841/// 1842/// postfix-expression: [C++ 5.2p1] 1843/// simple-type-specifier '(' expression-list[opt] ')' 1844/// [C++0x] simple-type-specifier braced-init-list 1845/// typename-specifier '(' expression-list[opt] ')' 1846/// [C++0x] typename-specifier braced-init-list 1847/// 1848/// In C++1z onwards, the type specifier can also be a template-name. 1849ExprResult 1850Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) { 1851 Declarator DeclaratorInfo(DS, DeclaratorContext::FunctionalCast); 1852 ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get(); 1853 1854 assert((Tok.is(tok::l_paren) || 1855 (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))) 1856 && "Expected '(' or '{'!"); 1857 1858 if (Tok.is(tok::l_brace)) { 1859 PreferredType.enterTypeCast(Tok.getLocation(), TypeRep.get()); 1860 ExprResult Init = ParseBraceInitializer(); 1861 if (Init.isInvalid()) 1862 return Init; 1863 Expr *InitList = Init.get(); 1864 return Actions.ActOnCXXTypeConstructExpr( 1865 TypeRep, InitList->getBeginLoc(), MultiExprArg(&InitList, 1), 1866 InitList->getEndLoc(), /*ListInitialization=*/true); 1867 } else { 1868 BalancedDelimiterTracker T(*this, tok::l_paren); 1869 T.consumeOpen(); 1870 1871 PreferredType.enterTypeCast(Tok.getLocation(), TypeRep.get()); 1872 1873 ExprVector Exprs; 1874 CommaLocsTy CommaLocs; 1875 1876 auto RunSignatureHelp = [&]() { 1877 QualType PreferredType; 1878 if (TypeRep) 1879 PreferredType = Actions.ProduceConstructorSignatureHelp( 1880 getCurScope(), TypeRep.get()->getCanonicalTypeInternal(), 1881 DS.getEndLoc(), Exprs, T.getOpenLocation()); 1882 CalledSignatureHelp = true; 1883 return PreferredType; 1884 }; 1885 1886 if (Tok.isNot(tok::r_paren)) { 1887 if (ParseExpressionList(Exprs, CommaLocs, [&] { 1888 PreferredType.enterFunctionArgument(Tok.getLocation(), 1889 RunSignatureHelp); 1890 })) { 1891 if (PP.isCodeCompletionReached() && !CalledSignatureHelp) 1892 RunSignatureHelp(); 1893 SkipUntil(tok::r_paren, StopAtSemi); 1894 return ExprError(); 1895 } 1896 } 1897 1898 // Match the ')'. 1899 T.consumeClose(); 1900 1901 // TypeRep could be null, if it references an invalid typedef. 1902 if (!TypeRep) 1903 return ExprError(); 1904 1905 assert((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&& 1906 "Unexpected number of commas!"); 1907 return Actions.ActOnCXXTypeConstructExpr(TypeRep, T.getOpenLocation(), 1908 Exprs, T.getCloseLocation(), 1909 /*ListInitialization=*/false); 1910 } 1911} 1912 1913/// ParseCXXCondition - if/switch/while condition expression. 1914/// 1915/// condition: 1916/// expression 1917/// type-specifier-seq declarator '=' assignment-expression 1918/// [C++11] type-specifier-seq declarator '=' initializer-clause 1919/// [C++11] type-specifier-seq declarator braced-init-list 1920/// [Clang] type-specifier-seq ref-qualifier[opt] '[' identifier-list ']' 1921/// brace-or-equal-initializer 1922/// [GNU] type-specifier-seq declarator simple-asm-expr[opt] attributes[opt] 1923/// '=' assignment-expression 1924/// 1925/// In C++1z, a condition may in some contexts be preceded by an 1926/// optional init-statement. This function will parse that too. 1927/// 1928/// \param InitStmt If non-null, an init-statement is permitted, and if present 1929/// will be parsed and stored here. 1930/// 1931/// \param Loc The location of the start of the statement that requires this 1932/// condition, e.g., the "for" in a for loop. 1933/// 1934/// \param FRI If non-null, a for range declaration is permitted, and if 1935/// present will be parsed and stored here, and a null result will be returned. 1936/// 1937/// \param EnterForConditionScope If true, enter a continue/break scope at the 1938/// appropriate moment for a 'for' loop. 1939/// 1940/// \returns The parsed condition. 1941Sema::ConditionResult Parser::ParseCXXCondition(StmtResult *InitStmt, 1942 SourceLocation Loc, 1943 Sema::ConditionKind CK, 1944 ForRangeInfo *FRI, 1945 bool EnterForConditionScope) { 1946 // Helper to ensure we always enter a continue/break scope if requested. 1947 struct ForConditionScopeRAII { 1948 Scope *S; 1949 void enter(bool IsConditionVariable) { 1950 if (S) { 1951 S->AddFlags(Scope::BreakScope | Scope::ContinueScope); 1952 S->setIsConditionVarScope(IsConditionVariable); 1953 } 1954 } 1955 ~ForConditionScopeRAII() { 1956 if (S) 1957 S->setIsConditionVarScope(false); 1958 } 1959 } ForConditionScope{EnterForConditionScope ? getCurScope() : nullptr}; 1960 1961 ParenBraceBracketBalancer BalancerRAIIObj(*this); 1962 PreferredType.enterCondition(Actions, Tok.getLocation()); 1963 1964 if (Tok.is(tok::code_completion)) { 1965 cutOffParsing(); 1966 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition); 1967 return Sema::ConditionError(); 1968 } 1969 1970 ParsedAttributesWithRange attrs(AttrFactory); 1971 MaybeParseCXX11Attributes(attrs); 1972 1973 const auto WarnOnInit = [this, &CK] { 1974 Diag(Tok.getLocation(), getLangOpts().CPlusPlus17 1975 ? diag::warn_cxx14_compat_init_statement 1976 : diag::ext_init_statement) 1977 << (CK == Sema::ConditionKind::Switch); 1978 }; 1979 1980 // Determine what kind of thing we have. 1981 switch (isCXXConditionDeclarationOrInitStatement(InitStmt, FRI)) { 1982 case ConditionOrInitStatement::Expression: { 1983 // If this is a for loop, we're entering its condition. 1984 ForConditionScope.enter(/*IsConditionVariable=*/false); 1985 1986 ProhibitAttributes(attrs); 1987 1988 // We can have an empty expression here. 1989 // if (; true); 1990 if (InitStmt && Tok.is(tok::semi)) { 1991 WarnOnInit(); 1992 SourceLocation SemiLoc = Tok.getLocation(); 1993 if (!Tok.hasLeadingEmptyMacro() && !SemiLoc.isMacroID()) { 1994 Diag(SemiLoc, diag::warn_empty_init_statement) 1995 << (CK == Sema::ConditionKind::Switch) 1996 << FixItHint::CreateRemoval(SemiLoc); 1997 } 1998 ConsumeToken(); 1999 *InitStmt = Actions.ActOnNullStmt(SemiLoc); 2000 return ParseCXXCondition(nullptr, Loc, CK); 2001 } 2002 2003 // Parse the expression. 2004 ExprResult Expr = ParseExpression(); // expression 2005 if (Expr.isInvalid()) 2006 return Sema::ConditionError(); 2007 2008 if (InitStmt && Tok.is(tok::semi)) { 2009 WarnOnInit(); 2010 *InitStmt = Actions.ActOnExprStmt(Expr.get()); 2011 ConsumeToken(); 2012 return ParseCXXCondition(nullptr, Loc, CK); 2013 } 2014 2015 return Actions.ActOnCondition(getCurScope(), Loc, Expr.get(), CK); 2016 } 2017 2018 case ConditionOrInitStatement::InitStmtDecl: { 2019 WarnOnInit(); 2020 SourceLocation DeclStart = Tok.getLocation(), DeclEnd; 2021 DeclGroupPtrTy DG = ParseSimpleDeclaration( 2022 DeclaratorContext::SelectionInit, DeclEnd, attrs, /*RequireSemi=*/true); 2023 *InitStmt = Actions.ActOnDeclStmt(DG, DeclStart, DeclEnd); 2024 return ParseCXXCondition(nullptr, Loc, CK); 2025 } 2026 2027 case ConditionOrInitStatement::ForRangeDecl: { 2028 // This is 'for (init-stmt; for-range-decl : range-expr)'. 2029 // We're not actually in a for loop yet, so 'break' and 'continue' aren't 2030 // permitted here. 2031 assert(FRI && "should not parse a for range declaration here"); 2032 SourceLocation DeclStart = Tok.getLocation(), DeclEnd; 2033 DeclGroupPtrTy DG = ParseSimpleDeclaration(DeclaratorContext::ForInit, 2034 DeclEnd, attrs, false, FRI); 2035 FRI->LoopVar = Actions.ActOnDeclStmt(DG, DeclStart, Tok.getLocation()); 2036 assert((FRI->ColonLoc.isValid() || !DG) && 2037 "cannot find for range declaration"); 2038 return Sema::ConditionResult(); 2039 } 2040 2041 case ConditionOrInitStatement::ConditionDecl: 2042 case ConditionOrInitStatement::Error: 2043 break; 2044 } 2045 2046 // If this is a for loop, we're entering its condition. 2047 ForConditionScope.enter(/*IsConditionVariable=*/true); 2048 2049 // type-specifier-seq 2050 DeclSpec DS(AttrFactory); 2051 DS.takeAttributesFrom(attrs); 2052 ParseSpecifierQualifierList(DS, AS_none, DeclSpecContext::DSC_condition); 2053 2054 // declarator 2055 Declarator DeclaratorInfo(DS, DeclaratorContext::Condition); 2056 ParseDeclarator(DeclaratorInfo); 2057 2058 // simple-asm-expr[opt] 2059 if (Tok.is(tok::kw_asm)) { 2060 SourceLocation Loc; 2061 ExprResult AsmLabel(ParseSimpleAsm(/*ForAsmLabel*/ true, &Loc)); 2062 if (AsmLabel.isInvalid()) { 2063 SkipUntil(tok::semi, StopAtSemi); 2064 return Sema::ConditionError(); 2065 } 2066 DeclaratorInfo.setAsmLabel(AsmLabel.get()); 2067 DeclaratorInfo.SetRangeEnd(Loc); 2068 } 2069 2070 // If attributes are present, parse them. 2071 MaybeParseGNUAttributes(DeclaratorInfo); 2072 2073 // Type-check the declaration itself. 2074 DeclResult Dcl = Actions.ActOnCXXConditionDeclaration(getCurScope(), 2075 DeclaratorInfo); 2076 if (Dcl.isInvalid()) 2077 return Sema::ConditionError(); 2078 Decl *DeclOut = Dcl.get(); 2079 2080 // '=' assignment-expression 2081 // If a '==' or '+=' is found, suggest a fixit to '='. 2082 bool CopyInitialization = isTokenEqualOrEqualTypo(); 2083 if (CopyInitialization) 2084 ConsumeToken(); 2085 2086 ExprResult InitExpr = ExprError(); 2087 if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) { 2088 Diag(Tok.getLocation(), 2089 diag::warn_cxx98_compat_generalized_initializer_lists); 2090 InitExpr = ParseBraceInitializer(); 2091 } else if (CopyInitialization) { 2092 PreferredType.enterVariableInit(Tok.getLocation(), DeclOut); 2093 InitExpr = ParseAssignmentExpression(); 2094 } else if (Tok.is(tok::l_paren)) { 2095 // This was probably an attempt to initialize the variable. 2096 SourceLocation LParen = ConsumeParen(), RParen = LParen; 2097 if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch)) 2098 RParen = ConsumeParen(); 2099 Diag(DeclOut->getLocation(), 2100 diag::err_expected_init_in_condition_lparen) 2101 << SourceRange(LParen, RParen); 2102 } else { 2103 Diag(DeclOut->getLocation(), diag::err_expected_init_in_condition); 2104 } 2105 2106 if (!InitExpr.isInvalid()) 2107 Actions.AddInitializerToDecl(DeclOut, InitExpr.get(), !CopyInitialization); 2108 else 2109 Actions.ActOnInitializerError(DeclOut); 2110 2111 Actions.FinalizeDeclaration(DeclOut); 2112 return Actions.ActOnConditionVariable(DeclOut, Loc, CK); 2113} 2114 2115/// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers. 2116/// This should only be called when the current token is known to be part of 2117/// simple-type-specifier. 2118/// 2119/// simple-type-specifier: 2120/// '::'[opt] nested-name-specifier[opt] type-name 2121/// '::'[opt] nested-name-specifier 'template' simple-template-id [TODO] 2122/// char 2123/// wchar_t 2124/// bool 2125/// short 2126/// int 2127/// long 2128/// signed 2129/// unsigned 2130/// float 2131/// double 2132/// void 2133/// [GNU] typeof-specifier 2134/// [C++0x] auto [TODO] 2135/// 2136/// type-name: 2137/// class-name 2138/// enum-name 2139/// typedef-name 2140/// 2141void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) { 2142 DS.SetRangeStart(Tok.getLocation()); 2143 const char *PrevSpec; 2144 unsigned DiagID; 2145 SourceLocation Loc = Tok.getLocation(); 2146 const clang::PrintingPolicy &Policy = 2147 Actions.getASTContext().getPrintingPolicy(); 2148 2149 switch (Tok.getKind()) { 2150 case tok::identifier: // foo::bar 2151 case tok::coloncolon: // ::foo::bar 2152 llvm_unreachable("Annotation token should already be formed!"); 2153 default: 2154 llvm_unreachable("Not a simple-type-specifier token!"); 2155 2156 // type-name 2157 case tok::annot_typename: { 2158 DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, 2159 getTypeAnnotation(Tok), Policy); 2160 DS.SetRangeEnd(Tok.getAnnotationEndLoc()); 2161 ConsumeAnnotationToken(); 2162 2163 DS.Finish(Actions, Policy); 2164 return; 2165 } 2166 2167 case tok::kw__ExtInt: { 2168 ExprResult ER = ParseExtIntegerArgument(); 2169 if (ER.isInvalid()) 2170 DS.SetTypeSpecError(); 2171 else 2172 DS.SetExtIntType(Loc, ER.get(), PrevSpec, DiagID, Policy); 2173 2174 // Do this here because we have already consumed the close paren. 2175 DS.SetRangeEnd(PrevTokLocation); 2176 DS.Finish(Actions, Policy); 2177 return; 2178 } 2179 2180 // builtin types 2181 case tok::kw_short: 2182 DS.SetTypeSpecWidth(TypeSpecifierWidth::Short, Loc, PrevSpec, DiagID, 2183 Policy); 2184 break; 2185 case tok::kw_long: 2186 DS.SetTypeSpecWidth(TypeSpecifierWidth::Long, Loc, PrevSpec, DiagID, 2187 Policy); 2188 break; 2189 case tok::kw___int64: 2190 DS.SetTypeSpecWidth(TypeSpecifierWidth::LongLong, Loc, PrevSpec, DiagID, 2191 Policy); 2192 break; 2193 case tok::kw_signed: 2194 DS.SetTypeSpecSign(TypeSpecifierSign::Signed, Loc, PrevSpec, DiagID); 2195 break; 2196 case tok::kw_unsigned: 2197 DS.SetTypeSpecSign(TypeSpecifierSign::Unsigned, Loc, PrevSpec, DiagID); 2198 break; 2199 case tok::kw_void: 2200 DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID, Policy); 2201 break; 2202 case tok::kw_char: 2203 DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID, Policy); 2204 break; 2205 case tok::kw_int: 2206 DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID, Policy); 2207 break; 2208 case tok::kw___int128: 2209 DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID, Policy); 2210 break; 2211 case tok::kw___bf16: 2212 DS.SetTypeSpecType(DeclSpec::TST_BFloat16, Loc, PrevSpec, DiagID, Policy); 2213 break; 2214 case tok::kw_half: 2215 DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID, Policy); 2216 break; 2217 case tok::kw_float: 2218 DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID, Policy); 2219 break; 2220 case tok::kw_double: 2221 DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID, Policy); 2222 break; 2223 case tok::kw__Float16: 2224 DS.SetTypeSpecType(DeclSpec::TST_float16, Loc, PrevSpec, DiagID, Policy); 2225 break; 2226 case tok::kw___float128: 2227 DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec, DiagID, Policy); 2228 break; 2229 case tok::kw_wchar_t: 2230 DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID, Policy); 2231 break; 2232 case tok::kw_char8_t: 2233 DS.SetTypeSpecType(DeclSpec::TST_char8, Loc, PrevSpec, DiagID, Policy); 2234 break; 2235 case tok::kw_char16_t: 2236 DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID, Policy); 2237 break; 2238 case tok::kw_char32_t: 2239 DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID, Policy); 2240 break; 2241 case tok::kw_bool: 2242 DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID, Policy); 2243 break; 2244#define GENERIC_IMAGE_TYPE(ImgType, Id) \ 2245 case tok::kw_##ImgType##_t: \ 2246 DS.SetTypeSpecType(DeclSpec::TST_##ImgType##_t, Loc, PrevSpec, DiagID, \ 2247 Policy); \ 2248 break; 2249#include "clang/Basic/OpenCLImageTypes.def" 2250 2251 case tok::annot_decltype: 2252 case tok::kw_decltype: 2253 DS.SetRangeEnd(ParseDecltypeSpecifier(DS)); 2254 return DS.Finish(Actions, Policy); 2255 2256 // GNU typeof support. 2257 case tok::kw_typeof: 2258 ParseTypeofSpecifier(DS); 2259 DS.Finish(Actions, Policy); 2260 return; 2261 } 2262 ConsumeAnyToken(); 2263 DS.SetRangeEnd(PrevTokLocation); 2264 DS.Finish(Actions, Policy); 2265} 2266 2267/// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++ 2268/// [dcl.name]), which is a non-empty sequence of type-specifiers, 2269/// e.g., "const short int". Note that the DeclSpec is *not* finished 2270/// by parsing the type-specifier-seq, because these sequences are 2271/// typically followed by some form of declarator. Returns true and 2272/// emits diagnostics if this is not a type-specifier-seq, false 2273/// otherwise. 2274/// 2275/// type-specifier-seq: [C++ 8.1] 2276/// type-specifier type-specifier-seq[opt] 2277/// 2278bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) { 2279 ParseSpecifierQualifierList(DS, AS_none, DeclSpecContext::DSC_type_specifier); 2280 DS.Finish(Actions, Actions.getASTContext().getPrintingPolicy()); 2281 return false; 2282} 2283 2284/// Finish parsing a C++ unqualified-id that is a template-id of 2285/// some form. 2286/// 2287/// This routine is invoked when a '<' is encountered after an identifier or 2288/// operator-function-id is parsed by \c ParseUnqualifiedId() to determine 2289/// whether the unqualified-id is actually a template-id. This routine will 2290/// then parse the template arguments and form the appropriate template-id to 2291/// return to the caller. 2292/// 2293/// \param SS the nested-name-specifier that precedes this template-id, if 2294/// we're actually parsing a qualified-id. 2295/// 2296/// \param ObjectType if this unqualified-id occurs within a member access 2297/// expression, the type of the base object whose member is being accessed. 2298/// 2299/// \param ObjectHadErrors this unqualified-id occurs within a member access 2300/// expression, indicates whether the original subexpressions had any errors. 2301/// 2302/// \param Name for constructor and destructor names, this is the actual 2303/// identifier that may be a template-name. 2304/// 2305/// \param NameLoc the location of the class-name in a constructor or 2306/// destructor. 2307/// 2308/// \param EnteringContext whether we're entering the scope of the 2309/// nested-name-specifier. 2310/// 2311/// \param Id as input, describes the template-name or operator-function-id 2312/// that precedes the '<'. If template arguments were parsed successfully, 2313/// will be updated with the template-id. 2314/// 2315/// \param AssumeTemplateId When true, this routine will assume that the name 2316/// refers to a template without performing name lookup to verify. 2317/// 2318/// \returns true if a parse error occurred, false otherwise. 2319bool Parser::ParseUnqualifiedIdTemplateId( 2320 CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors, 2321 SourceLocation TemplateKWLoc, IdentifierInfo *Name, SourceLocation NameLoc, 2322 bool EnteringContext, UnqualifiedId &Id, bool AssumeTemplateId) { 2323 assert(Tok.is(tok::less) && "Expected '<' to finish parsing a template-id"); 2324 2325 TemplateTy Template; 2326 TemplateNameKind TNK = TNK_Non_template; 2327 switch (Id.getKind()) { 2328 case UnqualifiedIdKind::IK_Identifier: 2329 case UnqualifiedIdKind::IK_OperatorFunctionId: 2330 case UnqualifiedIdKind::IK_LiteralOperatorId: 2331 if (AssumeTemplateId) { 2332 // We defer the injected-class-name checks until we've found whether 2333 // this template-id is used to form a nested-name-specifier or not. 2334 TNK = Actions.ActOnTemplateName(getCurScope(), SS, TemplateKWLoc, Id, 2335 ObjectType, EnteringContext, Template, 2336 /*AllowInjectedClassName*/ true); 2337 } else { 2338 bool MemberOfUnknownSpecialization; 2339 TNK = Actions.isTemplateName(getCurScope(), SS, 2340 TemplateKWLoc.isValid(), Id, 2341 ObjectType, EnteringContext, Template, 2342 MemberOfUnknownSpecialization); 2343 // If lookup found nothing but we're assuming that this is a template 2344 // name, double-check that makes sense syntactically before committing 2345 // to it. 2346 if (TNK == TNK_Undeclared_template && 2347 isTemplateArgumentList(0) == TPResult::False) 2348 return false; 2349 2350 if (TNK == TNK_Non_template && MemberOfUnknownSpecialization && 2351 ObjectType && isTemplateArgumentList(0) == TPResult::True) { 2352 // If we had errors before, ObjectType can be dependent even without any 2353 // templates, do not report missing template keyword in that case. 2354 if (!ObjectHadErrors) { 2355 // We have something like t->getAs<T>(), where getAs is a 2356 // member of an unknown specialization. However, this will only 2357 // parse correctly as a template, so suggest the keyword 'template' 2358 // before 'getAs' and treat this as a dependent template name. 2359 std::string Name; 2360 if (Id.getKind() == UnqualifiedIdKind::IK_Identifier) 2361 Name = std::string(Id.Identifier->getName()); 2362 else { 2363 Name = "operator "; 2364 if (Id.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId) 2365 Name += getOperatorSpelling(Id.OperatorFunctionId.Operator); 2366 else 2367 Name += Id.Identifier->getName(); 2368 } 2369 Diag(Id.StartLocation, diag::err_missing_dependent_template_keyword) 2370 << Name 2371 << FixItHint::CreateInsertion(Id.StartLocation, "template "); 2372 } 2373 TNK = Actions.ActOnTemplateName( 2374 getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext, 2375 Template, /*AllowInjectedClassName*/ true); 2376 } else if (TNK == TNK_Non_template) { 2377 return false; 2378 } 2379 } 2380 break; 2381 2382 case UnqualifiedIdKind::IK_ConstructorName: { 2383 UnqualifiedId TemplateName; 2384 bool MemberOfUnknownSpecialization; 2385 TemplateName.setIdentifier(Name, NameLoc); 2386 TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(), 2387 TemplateName, ObjectType, 2388 EnteringContext, Template, 2389 MemberOfUnknownSpecialization); 2390 if (TNK == TNK_Non_template) 2391 return false; 2392 break; 2393 } 2394 2395 case UnqualifiedIdKind::IK_DestructorName: { 2396 UnqualifiedId TemplateName; 2397 bool MemberOfUnknownSpecialization; 2398 TemplateName.setIdentifier(Name, NameLoc); 2399 if (ObjectType) { 2400 TNK = Actions.ActOnTemplateName( 2401 getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType, 2402 EnteringContext, Template, /*AllowInjectedClassName*/ true); 2403 } else { 2404 TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(), 2405 TemplateName, ObjectType, 2406 EnteringContext, Template, 2407 MemberOfUnknownSpecialization); 2408 2409 if (TNK == TNK_Non_template && !Id.DestructorName.get()) { 2410 Diag(NameLoc, diag::err_destructor_template_id) 2411 << Name << SS.getRange(); 2412 // Carry on to parse the template arguments before bailing out. 2413 } 2414 } 2415 break; 2416 } 2417 2418 default: 2419 return false; 2420 } 2421 2422 // Parse the enclosed template argument list. 2423 SourceLocation LAngleLoc, RAngleLoc; 2424 TemplateArgList TemplateArgs; 2425 if (ParseTemplateIdAfterTemplateName(true, LAngleLoc, TemplateArgs, 2426 RAngleLoc)) 2427 return true; 2428 2429 // If this is a non-template, we already issued a diagnostic. 2430 if (TNK == TNK_Non_template) 2431 return true; 2432 2433 if (Id.getKind() == UnqualifiedIdKind::IK_Identifier || 2434 Id.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId || 2435 Id.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId) { 2436 // Form a parsed representation of the template-id to be stored in the 2437 // UnqualifiedId. 2438 2439 // FIXME: Store name for literal operator too. 2440 IdentifierInfo *TemplateII = 2441 Id.getKind() == UnqualifiedIdKind::IK_Identifier ? Id.Identifier 2442 : nullptr; 2443 OverloadedOperatorKind OpKind = 2444 Id.getKind() == UnqualifiedIdKind::IK_Identifier 2445 ? OO_None 2446 : Id.OperatorFunctionId.Operator; 2447 2448 TemplateIdAnnotation *TemplateId = TemplateIdAnnotation::Create( 2449 TemplateKWLoc, Id.StartLocation, TemplateII, OpKind, Template, TNK, 2450 LAngleLoc, RAngleLoc, TemplateArgs, /*ArgsInvalid*/false, TemplateIds); 2451 2452 Id.setTemplateId(TemplateId); 2453 return false; 2454 } 2455 2456 // Bundle the template arguments together. 2457 ASTTemplateArgsPtr TemplateArgsPtr(TemplateArgs); 2458 2459 // Constructor and destructor names. 2460 TypeResult Type = Actions.ActOnTemplateIdType( 2461 getCurScope(), SS, TemplateKWLoc, Template, Name, NameLoc, LAngleLoc, 2462 TemplateArgsPtr, RAngleLoc, /*IsCtorOrDtorName=*/true); 2463 if (Type.isInvalid()) 2464 return true; 2465 2466 if (Id.getKind() == UnqualifiedIdKind::IK_ConstructorName) 2467 Id.setConstructorName(Type.get(), NameLoc, RAngleLoc); 2468 else 2469 Id.setDestructorName(Id.StartLocation, Type.get(), RAngleLoc); 2470 2471 return false; 2472} 2473 2474/// Parse an operator-function-id or conversion-function-id as part 2475/// of a C++ unqualified-id. 2476/// 2477/// This routine is responsible only for parsing the operator-function-id or 2478/// conversion-function-id; it does not handle template arguments in any way. 2479/// 2480/// \code 2481/// operator-function-id: [C++ 13.5] 2482/// 'operator' operator 2483/// 2484/// operator: one of 2485/// new delete new[] delete[] 2486/// + - * / % ^ & | ~ 2487/// ! = < > += -= *= /= %= 2488/// ^= &= |= << >> >>= <<= == != 2489/// <= >= && || ++ -- , ->* -> 2490/// () [] <=> 2491/// 2492/// conversion-function-id: [C++ 12.3.2] 2493/// operator conversion-type-id 2494/// 2495/// conversion-type-id: 2496/// type-specifier-seq conversion-declarator[opt] 2497/// 2498/// conversion-declarator: 2499/// ptr-operator conversion-declarator[opt] 2500/// \endcode 2501/// 2502/// \param SS The nested-name-specifier that preceded this unqualified-id. If 2503/// non-empty, then we are parsing the unqualified-id of a qualified-id. 2504/// 2505/// \param EnteringContext whether we are entering the scope of the 2506/// nested-name-specifier. 2507/// 2508/// \param ObjectType if this unqualified-id occurs within a member access 2509/// expression, the type of the base object whose member is being accessed. 2510/// 2511/// \param Result on a successful parse, contains the parsed unqualified-id. 2512/// 2513/// \returns true if parsing fails, false otherwise. 2514bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext, 2515 ParsedType ObjectType, 2516 UnqualifiedId &Result) { 2517 assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword"); 2518 2519 // Consume the 'operator' keyword. 2520 SourceLocation KeywordLoc = ConsumeToken(); 2521 2522 // Determine what kind of operator name we have. 2523 unsigned SymbolIdx = 0; 2524 SourceLocation SymbolLocations[3]; 2525 OverloadedOperatorKind Op = OO_None; 2526 switch (Tok.getKind()) { 2527 case tok::kw_new: 2528 case tok::kw_delete: { 2529 bool isNew = Tok.getKind() == tok::kw_new; 2530 // Consume the 'new' or 'delete'. 2531 SymbolLocations[SymbolIdx++] = ConsumeToken(); 2532 // Check for array new/delete. 2533 if (Tok.is(tok::l_square) && 2534 (!getLangOpts().CPlusPlus11 || NextToken().isNot(tok::l_square))) { 2535 // Consume the '[' and ']'. 2536 BalancedDelimiterTracker T(*this, tok::l_square); 2537 T.consumeOpen(); 2538 T.consumeClose(); 2539 if (T.getCloseLocation().isInvalid()) 2540 return true; 2541 2542 SymbolLocations[SymbolIdx++] = T.getOpenLocation(); 2543 SymbolLocations[SymbolIdx++] = T.getCloseLocation(); 2544 Op = isNew? OO_Array_New : OO_Array_Delete; 2545 } else { 2546 Op = isNew? OO_New : OO_Delete; 2547 } 2548 break; 2549 } 2550 2551#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 2552 case tok::Token: \ 2553 SymbolLocations[SymbolIdx++] = ConsumeToken(); \ 2554 Op = OO_##Name; \ 2555 break; 2556#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly) 2557#include "clang/Basic/OperatorKinds.def" 2558 2559 case tok::l_paren: { 2560 // Consume the '(' and ')'. 2561 BalancedDelimiterTracker T(*this, tok::l_paren); 2562 T.consumeOpen(); 2563 T.consumeClose(); 2564 if (T.getCloseLocation().isInvalid()) 2565 return true; 2566 2567 SymbolLocations[SymbolIdx++] = T.getOpenLocation(); 2568 SymbolLocations[SymbolIdx++] = T.getCloseLocation(); 2569 Op = OO_Call; 2570 break; 2571 } 2572 2573 case tok::l_square: { 2574 // Consume the '[' and ']'. 2575 BalancedDelimiterTracker T(*this, tok::l_square); 2576 T.consumeOpen(); 2577 T.consumeClose(); 2578 if (T.getCloseLocation().isInvalid()) 2579 return true; 2580 2581 SymbolLocations[SymbolIdx++] = T.getOpenLocation(); 2582 SymbolLocations[SymbolIdx++] = T.getCloseLocation(); 2583 Op = OO_Subscript; 2584 break; 2585 } 2586 2587 case tok::code_completion: { 2588 // Don't try to parse any further. 2589 cutOffParsing(); 2590 // Code completion for the operator name. 2591 Actions.CodeCompleteOperatorName(getCurScope()); 2592 return true; 2593 } 2594 2595 default: 2596 break; 2597 } 2598 2599 if (Op != OO_None) { 2600 // We have parsed an operator-function-id. 2601 Result.setOperatorFunctionId(KeywordLoc, Op, SymbolLocations); 2602 return false; 2603 } 2604 2605 // Parse a literal-operator-id. 2606 // 2607 // literal-operator-id: C++11 [over.literal] 2608 // operator string-literal identifier 2609 // operator user-defined-string-literal 2610 2611 if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) { 2612 Diag(Tok.getLocation(), diag::warn_cxx98_compat_literal_operator); 2613 2614 SourceLocation DiagLoc; 2615 unsigned DiagId = 0; 2616 2617 // We're past translation phase 6, so perform string literal concatenation 2618 // before checking for "". 2619 SmallVector<Token, 4> Toks; 2620 SmallVector<SourceLocation, 4> TokLocs; 2621 while (isTokenStringLiteral()) { 2622 if (!Tok.is(tok::string_literal) && !DiagId) { 2623 // C++11 [over.literal]p1: 2624 // The string-literal or user-defined-string-literal in a 2625 // literal-operator-id shall have no encoding-prefix [...]. 2626 DiagLoc = Tok.getLocation(); 2627 DiagId = diag::err_literal_operator_string_prefix; 2628 } 2629 Toks.push_back(Tok); 2630 TokLocs.push_back(ConsumeStringToken()); 2631 } 2632 2633 StringLiteralParser Literal(Toks, PP); 2634 if (Literal.hadError) 2635 return true; 2636 2637 // Grab the literal operator's suffix, which will be either the next token 2638 // or a ud-suffix from the string literal. 2639 IdentifierInfo *II = nullptr; 2640 SourceLocation SuffixLoc; 2641 if (!Literal.getUDSuffix().empty()) { 2642 II = &PP.getIdentifierTable().get(Literal.getUDSuffix()); 2643 SuffixLoc = 2644 Lexer::AdvanceToTokenCharacter(TokLocs[Literal.getUDSuffixToken()], 2645 Literal.getUDSuffixOffset(), 2646 PP.getSourceManager(), getLangOpts()); 2647 } else if (Tok.is(tok::identifier)) { 2648 II = Tok.getIdentifierInfo(); 2649 SuffixLoc = ConsumeToken(); 2650 TokLocs.push_back(SuffixLoc); 2651 } else { 2652 Diag(Tok.getLocation(), diag::err_expected) << tok::identifier; 2653 return true; 2654 } 2655 2656 // The string literal must be empty. 2657 if (!Literal.GetString().empty() || Literal.Pascal) { 2658 // C++11 [over.literal]p1: 2659 // The string-literal or user-defined-string-literal in a 2660 // literal-operator-id shall [...] contain no characters 2661 // other than the implicit terminating '\0'. 2662 DiagLoc = TokLocs.front(); 2663 DiagId = diag::err_literal_operator_string_not_empty; 2664 } 2665 2666 if (DiagId) { 2667 // This isn't a valid literal-operator-id, but we think we know 2668 // what the user meant. Tell them what they should have written. 2669 SmallString<32> Str; 2670 Str += "\"\""; 2671 Str += II->getName(); 2672 Diag(DiagLoc, DiagId) << FixItHint::CreateReplacement( 2673 SourceRange(TokLocs.front(), TokLocs.back()), Str); 2674 } 2675 2676 Result.setLiteralOperatorId(II, KeywordLoc, SuffixLoc); 2677 2678 return Actions.checkLiteralOperatorId(SS, Result); 2679 } 2680 2681 // Parse a conversion-function-id. 2682 // 2683 // conversion-function-id: [C++ 12.3.2] 2684 // operator conversion-type-id 2685 // 2686 // conversion-type-id: 2687 // type-specifier-seq conversion-declarator[opt] 2688 // 2689 // conversion-declarator: 2690 // ptr-operator conversion-declarator[opt] 2691 2692 // Parse the type-specifier-seq. 2693 DeclSpec DS(AttrFactory); 2694 if (ParseCXXTypeSpecifierSeq(DS)) // FIXME: ObjectType? 2695 return true; 2696 2697 // Parse the conversion-declarator, which is merely a sequence of 2698 // ptr-operators. 2699 Declarator D(DS, DeclaratorContext::ConversionId); 2700 ParseDeclaratorInternal(D, /*DirectDeclParser=*/nullptr); 2701 2702 // Finish up the type. 2703 TypeResult Ty = Actions.ActOnTypeName(getCurScope(), D); 2704 if (Ty.isInvalid()) 2705 return true; 2706 2707 // Note that this is a conversion-function-id. 2708 Result.setConversionFunctionId(KeywordLoc, Ty.get(), 2709 D.getSourceRange().getEnd()); 2710 return false; 2711} 2712 2713/// Parse a C++ unqualified-id (or a C identifier), which describes the 2714/// name of an entity. 2715/// 2716/// \code 2717/// unqualified-id: [C++ expr.prim.general] 2718/// identifier 2719/// operator-function-id 2720/// conversion-function-id 2721/// [C++0x] literal-operator-id [TODO] 2722/// ~ class-name 2723/// template-id 2724/// 2725/// \endcode 2726/// 2727/// \param SS The nested-name-specifier that preceded this unqualified-id. If 2728/// non-empty, then we are parsing the unqualified-id of a qualified-id. 2729/// 2730/// \param ObjectType if this unqualified-id occurs within a member access 2731/// expression, the type of the base object whose member is being accessed. 2732/// 2733/// \param ObjectHadErrors if this unqualified-id occurs within a member access 2734/// expression, indicates whether the original subexpressions had any errors. 2735/// When true, diagnostics for missing 'template' keyword will be supressed. 2736/// 2737/// \param EnteringContext whether we are entering the scope of the 2738/// nested-name-specifier. 2739/// 2740/// \param AllowDestructorName whether we allow parsing of a destructor name. 2741/// 2742/// \param AllowConstructorName whether we allow parsing a constructor name. 2743/// 2744/// \param AllowDeductionGuide whether we allow parsing a deduction guide name. 2745/// 2746/// \param Result on a successful parse, contains the parsed unqualified-id. 2747/// 2748/// \returns true if parsing fails, false otherwise. 2749bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, ParsedType ObjectType, 2750 bool ObjectHadErrors, bool EnteringContext, 2751 bool AllowDestructorName, 2752 bool AllowConstructorName, 2753 bool AllowDeductionGuide, 2754 SourceLocation *TemplateKWLoc, 2755 UnqualifiedId &Result) { 2756 if (TemplateKWLoc) 2757 *TemplateKWLoc = SourceLocation(); 2758 2759 // Handle 'A::template B'. This is for template-ids which have not 2760 // already been annotated by ParseOptionalCXXScopeSpecifier(). 2761 bool TemplateSpecified = false; 2762 if (Tok.is(tok::kw_template)) { 2763 if (TemplateKWLoc && (ObjectType || SS.isSet())) { 2764 TemplateSpecified = true; 2765 *TemplateKWLoc = ConsumeToken(); 2766 } else { 2767 SourceLocation TemplateLoc = ConsumeToken(); 2768 Diag(TemplateLoc, diag::err_unexpected_template_in_unqualified_id) 2769 << FixItHint::CreateRemoval(TemplateLoc); 2770 } 2771 } 2772 2773 // unqualified-id: 2774 // identifier 2775 // template-id (when it hasn't already been annotated) 2776 if (Tok.is(tok::identifier)) { 2777 // Consume the identifier. 2778 IdentifierInfo *Id = Tok.getIdentifierInfo(); 2779 SourceLocation IdLoc = ConsumeToken(); 2780 2781 if (!getLangOpts().CPlusPlus) { 2782 // If we're not in C++, only identifiers matter. Record the 2783 // identifier and return. 2784 Result.setIdentifier(Id, IdLoc); 2785 return false; 2786 } 2787 2788 ParsedTemplateTy TemplateName; 2789 if (AllowConstructorName && 2790 Actions.isCurrentClassName(*Id, getCurScope(), &SS)) { 2791 // We have parsed a constructor name. 2792 ParsedType Ty = Actions.getConstructorName(*Id, IdLoc, getCurScope(), SS, 2793 EnteringContext); 2794 if (!Ty) 2795 return true; 2796 Result.setConstructorName(Ty, IdLoc, IdLoc); 2797 } else if (getLangOpts().CPlusPlus17 && 2798 AllowDeductionGuide && SS.isEmpty() && 2799 Actions.isDeductionGuideName(getCurScope(), *Id, IdLoc, 2800 &TemplateName)) { 2801 // We have parsed a template-name naming a deduction guide. 2802 Result.setDeductionGuideName(TemplateName, IdLoc); 2803 } else { 2804 // We have parsed an identifier. 2805 Result.setIdentifier(Id, IdLoc); 2806 } 2807 2808 // If the next token is a '<', we may have a template. 2809 TemplateTy Template; 2810 if (Tok.is(tok::less)) 2811 return ParseUnqualifiedIdTemplateId( 2812 SS, ObjectType, ObjectHadErrors, 2813 TemplateKWLoc ? *TemplateKWLoc : SourceLocation(), Id, IdLoc, 2814 EnteringContext, Result, TemplateSpecified); 2815 else if (TemplateSpecified && 2816 Actions.ActOnTemplateName( 2817 getCurScope(), SS, *TemplateKWLoc, Result, ObjectType, 2818 EnteringContext, Template, 2819 /*AllowInjectedClassName*/ true) == TNK_Non_template) 2820 return true; 2821 2822 return false; 2823 } 2824 2825 // unqualified-id: 2826 // template-id (already parsed and annotated) 2827 if (Tok.is(tok::annot_template_id)) { 2828 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); 2829 2830 // FIXME: Consider passing invalid template-ids on to callers; they may 2831 // be able to recover better than we can. 2832 if (TemplateId->isInvalid()) { 2833 ConsumeAnnotationToken(); 2834 return true; 2835 } 2836 2837 // If the template-name names the current class, then this is a constructor 2838 if (AllowConstructorName && TemplateId->Name && 2839 Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) { 2840 if (SS.isSet()) { 2841 // C++ [class.qual]p2 specifies that a qualified template-name 2842 // is taken as the constructor name where a constructor can be 2843 // declared. Thus, the template arguments are extraneous, so 2844 // complain about them and remove them entirely. 2845 Diag(TemplateId->TemplateNameLoc, 2846 diag::err_out_of_line_constructor_template_id) 2847 << TemplateId->Name 2848 << FixItHint::CreateRemoval( 2849 SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc)); 2850 ParsedType Ty = Actions.getConstructorName( 2851 *TemplateId->Name, TemplateId->TemplateNameLoc, getCurScope(), SS, 2852 EnteringContext); 2853 if (!Ty) 2854 return true; 2855 Result.setConstructorName(Ty, TemplateId->TemplateNameLoc, 2856 TemplateId->RAngleLoc); 2857 ConsumeAnnotationToken(); 2858 return false; 2859 } 2860 2861 Result.setConstructorTemplateId(TemplateId); 2862 ConsumeAnnotationToken(); 2863 return false; 2864 } 2865 2866 // We have already parsed a template-id; consume the annotation token as 2867 // our unqualified-id. 2868 Result.setTemplateId(TemplateId); 2869 SourceLocation TemplateLoc = TemplateId->TemplateKWLoc; 2870 if (TemplateLoc.isValid()) { 2871 if (TemplateKWLoc && (ObjectType || SS.isSet())) 2872 *TemplateKWLoc = TemplateLoc; 2873 else 2874 Diag(TemplateLoc, diag::err_unexpected_template_in_unqualified_id) 2875 << FixItHint::CreateRemoval(TemplateLoc); 2876 } 2877 ConsumeAnnotationToken(); 2878 return false; 2879 } 2880 2881 // unqualified-id: 2882 // operator-function-id 2883 // conversion-function-id 2884 if (Tok.is(tok::kw_operator)) { 2885 if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, Result)) 2886 return true; 2887 2888 // If we have an operator-function-id or a literal-operator-id and the next 2889 // token is a '<', we may have a 2890 // 2891 // template-id: 2892 // operator-function-id < template-argument-list[opt] > 2893 TemplateTy Template; 2894 if ((Result.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId || 2895 Result.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId) && 2896 Tok.is(tok::less)) 2897 return ParseUnqualifiedIdTemplateId( 2898 SS, ObjectType, ObjectHadErrors, 2899 TemplateKWLoc ? *TemplateKWLoc : SourceLocation(), nullptr, 2900 SourceLocation(), EnteringContext, Result, TemplateSpecified); 2901 else if (TemplateSpecified && 2902 Actions.ActOnTemplateName( 2903 getCurScope(), SS, *TemplateKWLoc, Result, ObjectType, 2904 EnteringContext, Template, 2905 /*AllowInjectedClassName*/ true) == TNK_Non_template) 2906 return true; 2907 2908 return false; 2909 } 2910 2911 if (getLangOpts().CPlusPlus && 2912 (AllowDestructorName || SS.isSet()) && Tok.is(tok::tilde)) { 2913 // C++ [expr.unary.op]p10: 2914 // There is an ambiguity in the unary-expression ~X(), where X is a 2915 // class-name. The ambiguity is resolved in favor of treating ~ as a 2916 // unary complement rather than treating ~X as referring to a destructor. 2917 2918 // Parse the '~'. 2919 SourceLocation TildeLoc = ConsumeToken(); 2920 2921 if (TemplateSpecified) { 2922 // C++ [temp.names]p3: 2923 // A name prefixed by the keyword template shall be a template-id [...] 2924 // 2925 // A template-id cannot begin with a '~' token. This would never work 2926 // anyway: x.~A<int>() would specify that the destructor is a template, 2927 // not that 'A' is a template. 2928 // 2929 // FIXME: Suggest replacing the attempted destructor name with a correct 2930 // destructor name and recover. (This is not trivial if this would become 2931 // a pseudo-destructor name). 2932 Diag(*TemplateKWLoc, diag::err_unexpected_template_in_destructor_name) 2933 << Tok.getLocation(); 2934 return true; 2935 } 2936 2937 if (SS.isEmpty() && Tok.is(tok::kw_decltype)) { 2938 DeclSpec DS(AttrFactory); 2939 SourceLocation EndLoc = ParseDecltypeSpecifier(DS); 2940 if (ParsedType Type = 2941 Actions.getDestructorTypeForDecltype(DS, ObjectType)) { 2942 Result.setDestructorName(TildeLoc, Type, EndLoc); 2943 return false; 2944 } 2945 return true; 2946 } 2947 2948 // Parse the class-name. 2949 if (Tok.isNot(tok::identifier)) { 2950 Diag(Tok, diag::err_destructor_tilde_identifier); 2951 return true; 2952 } 2953 2954 // If the user wrote ~T::T, correct it to T::~T. 2955 DeclaratorScopeObj DeclScopeObj(*this, SS); 2956 if (NextToken().is(tok::coloncolon)) { 2957 // Don't let ParseOptionalCXXScopeSpecifier() "correct" 2958 // `int A; struct { ~A::A(); };` to `int A; struct { ~A:A(); };`, 2959 // it will confuse this recovery logic. 2960 ColonProtectionRAIIObject ColonRAII(*this, false); 2961 2962 if (SS.isSet()) { 2963 AnnotateScopeToken(SS, /*NewAnnotation*/true); 2964 SS.clear(); 2965 } 2966 if (ParseOptionalCXXScopeSpecifier(SS, ObjectType, ObjectHadErrors, 2967 EnteringContext)) 2968 return true; 2969 if (SS.isNotEmpty()) 2970 ObjectType = nullptr; 2971 if (Tok.isNot(tok::identifier) || NextToken().is(tok::coloncolon) || 2972 !SS.isSet()) { 2973 Diag(TildeLoc, diag::err_destructor_tilde_scope); 2974 return true; 2975 } 2976 2977 // Recover as if the tilde had been written before the identifier. 2978 Diag(TildeLoc, diag::err_destructor_tilde_scope) 2979 << FixItHint::CreateRemoval(TildeLoc) 2980 << FixItHint::CreateInsertion(Tok.getLocation(), "~"); 2981 2982 // Temporarily enter the scope for the rest of this function. 2983 if (Actions.ShouldEnterDeclaratorScope(getCurScope(), SS)) 2984 DeclScopeObj.EnterDeclaratorScope(); 2985 } 2986 2987 // Parse the class-name (or template-name in a simple-template-id). 2988 IdentifierInfo *ClassName = Tok.getIdentifierInfo(); 2989 SourceLocation ClassNameLoc = ConsumeToken(); 2990 2991 if (Tok.is(tok::less)) { 2992 Result.setDestructorName(TildeLoc, nullptr, ClassNameLoc); 2993 return ParseUnqualifiedIdTemplateId( 2994 SS, ObjectType, ObjectHadErrors, 2995 TemplateKWLoc ? *TemplateKWLoc : SourceLocation(), ClassName, 2996 ClassNameLoc, EnteringContext, Result, TemplateSpecified); 2997 } 2998 2999 // Note that this is a destructor name. 3000 ParsedType Ty = Actions.getDestructorName(TildeLoc, *ClassName, 3001 ClassNameLoc, getCurScope(), 3002 SS, ObjectType, 3003 EnteringContext); 3004 if (!Ty) 3005 return true; 3006 3007 Result.setDestructorName(TildeLoc, Ty, ClassNameLoc); 3008 return false; 3009 } 3010 3011 Diag(Tok, diag::err_expected_unqualified_id) 3012 << getLangOpts().CPlusPlus; 3013 return true; 3014} 3015 3016/// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate 3017/// memory in a typesafe manner and call constructors. 3018/// 3019/// This method is called to parse the new expression after the optional :: has 3020/// been already parsed. If the :: was present, "UseGlobal" is true and "Start" 3021/// is its location. Otherwise, "Start" is the location of the 'new' token. 3022/// 3023/// new-expression: 3024/// '::'[opt] 'new' new-placement[opt] new-type-id 3025/// new-initializer[opt] 3026/// '::'[opt] 'new' new-placement[opt] '(' type-id ')' 3027/// new-initializer[opt] 3028/// 3029/// new-placement: 3030/// '(' expression-list ')' 3031/// 3032/// new-type-id: 3033/// type-specifier-seq new-declarator[opt] 3034/// [GNU] attributes type-specifier-seq new-declarator[opt] 3035/// 3036/// new-declarator: 3037/// ptr-operator new-declarator[opt] 3038/// direct-new-declarator 3039/// 3040/// new-initializer: 3041/// '(' expression-list[opt] ')' 3042/// [C++0x] braced-init-list 3043/// 3044ExprResult 3045Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) { 3046 assert(Tok.is(tok::kw_new) && "expected 'new' token"); 3047 ConsumeToken(); // Consume 'new' 3048 3049 // A '(' now can be a new-placement or the '(' wrapping the type-id in the 3050 // second form of new-expression. It can't be a new-type-id. 3051 3052 ExprVector PlacementArgs; 3053 SourceLocation PlacementLParen, PlacementRParen; 3054 3055 SourceRange TypeIdParens; 3056 DeclSpec DS(AttrFactory); 3057 Declarator DeclaratorInfo(DS, DeclaratorContext::CXXNew); 3058 if (Tok.is(tok::l_paren)) { 3059 // If it turns out to be a placement, we change the type location. 3060 BalancedDelimiterTracker T(*this, tok::l_paren); 3061 T.consumeOpen(); 3062 PlacementLParen = T.getOpenLocation(); 3063 if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) { 3064 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch); 3065 return ExprError(); 3066 } 3067 3068 T.consumeClose(); 3069 PlacementRParen = T.getCloseLocation(); 3070 if (PlacementRParen.isInvalid()) { 3071 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch); 3072 return ExprError(); 3073 } 3074 3075 if (PlacementArgs.empty()) { 3076 // Reset the placement locations. There was no placement. 3077 TypeIdParens = T.getRange(); 3078 PlacementLParen = PlacementRParen = SourceLocation(); 3079 } else { 3080 // We still need the type. 3081 if (Tok.is(tok::l_paren)) { 3082 BalancedDelimiterTracker T(*this, tok::l_paren); 3083 T.consumeOpen(); 3084 MaybeParseGNUAttributes(DeclaratorInfo); 3085 ParseSpecifierQualifierList(DS); 3086 DeclaratorInfo.SetSourceRange(DS.getSourceRange()); 3087 ParseDeclarator(DeclaratorInfo); 3088 T.consumeClose(); 3089 TypeIdParens = T.getRange(); 3090 } else { 3091 MaybeParseGNUAttributes(DeclaratorInfo); 3092 if (ParseCXXTypeSpecifierSeq(DS)) 3093 DeclaratorInfo.setInvalidType(true); 3094 else { 3095 DeclaratorInfo.SetSourceRange(DS.getSourceRange()); 3096 ParseDeclaratorInternal(DeclaratorInfo, 3097 &Parser::ParseDirectNewDeclarator); 3098 } 3099 } 3100 } 3101 } else { 3102 // A new-type-id is a simplified type-id, where essentially the 3103 // direct-declarator is replaced by a direct-new-declarator. 3104 MaybeParseGNUAttributes(DeclaratorInfo); 3105 if (ParseCXXTypeSpecifierSeq(DS)) 3106 DeclaratorInfo.setInvalidType(true); 3107 else { 3108 DeclaratorInfo.SetSourceRange(DS.getSourceRange()); 3109 ParseDeclaratorInternal(DeclaratorInfo, 3110 &Parser::ParseDirectNewDeclarator); 3111 } 3112 } 3113 if (DeclaratorInfo.isInvalidType()) { 3114 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch); 3115 return ExprError(); 3116 } 3117 3118 ExprResult Initializer; 3119 3120 if (Tok.is(tok::l_paren)) { 3121 SourceLocation ConstructorLParen, ConstructorRParen; 3122 ExprVector ConstructorArgs; 3123 BalancedDelimiterTracker T(*this, tok::l_paren); 3124 T.consumeOpen(); 3125 ConstructorLParen = T.getOpenLocation(); 3126 if (Tok.isNot(tok::r_paren)) { 3127 CommaLocsTy CommaLocs; 3128 auto RunSignatureHelp = [&]() { 3129 ParsedType TypeRep = 3130 Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get(); 3131 QualType PreferredType; 3132 // ActOnTypeName might adjust DeclaratorInfo and return a null type even 3133 // the passing DeclaratorInfo is valid, e.g. running SignatureHelp on 3134 // `new decltype(invalid) (^)`. 3135 if (TypeRep) 3136 PreferredType = Actions.ProduceConstructorSignatureHelp( 3137 getCurScope(), TypeRep.get()->getCanonicalTypeInternal(), 3138 DeclaratorInfo.getEndLoc(), ConstructorArgs, ConstructorLParen); 3139 CalledSignatureHelp = true; 3140 return PreferredType; 3141 }; 3142 if (ParseExpressionList(ConstructorArgs, CommaLocs, [&] { 3143 PreferredType.enterFunctionArgument(Tok.getLocation(), 3144 RunSignatureHelp); 3145 })) { 3146 if (PP.isCodeCompletionReached() && !CalledSignatureHelp) 3147 RunSignatureHelp(); 3148 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch); 3149 return ExprError(); 3150 } 3151 } 3152 T.consumeClose(); 3153 ConstructorRParen = T.getCloseLocation(); 3154 if (ConstructorRParen.isInvalid()) { 3155 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch); 3156 return ExprError(); 3157 } 3158 Initializer = Actions.ActOnParenListExpr(ConstructorLParen, 3159 ConstructorRParen, 3160 ConstructorArgs); 3161 } else if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus11) { 3162 Diag(Tok.getLocation(), 3163 diag::warn_cxx98_compat_generalized_initializer_lists); 3164 Initializer = ParseBraceInitializer(); 3165 } 3166 if (Initializer.isInvalid()) 3167 return Initializer; 3168 3169 return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen, 3170 PlacementArgs, PlacementRParen, 3171 TypeIdParens, DeclaratorInfo, Initializer.get()); 3172} 3173 3174/// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be 3175/// passed to ParseDeclaratorInternal. 3176/// 3177/// direct-new-declarator: 3178/// '[' expression[opt] ']' 3179/// direct-new-declarator '[' constant-expression ']' 3180/// 3181void Parser::ParseDirectNewDeclarator(Declarator &D) { 3182 // Parse the array dimensions. 3183 bool First = true; 3184 while (Tok.is(tok::l_square)) { 3185 // An array-size expression can't start with a lambda. 3186 if (CheckProhibitedCXX11Attribute()) 3187 continue; 3188 3189 BalancedDelimiterTracker T(*this, tok::l_square); 3190 T.consumeOpen(); 3191 3192 ExprResult Size = 3193 First ? (Tok.is(tok::r_square) ? ExprResult() : ParseExpression()) 3194 : ParseConstantExpression(); 3195 if (Size.isInvalid()) { 3196 // Recover 3197 SkipUntil(tok::r_square, StopAtSemi); 3198 return; 3199 } 3200 First = false; 3201 3202 T.consumeClose(); 3203 3204 // Attributes here appertain to the array type. C++11 [expr.new]p5. 3205 ParsedAttributes Attrs(AttrFactory); 3206 MaybeParseCXX11Attributes(Attrs); 3207 3208 D.AddTypeInfo(DeclaratorChunk::getArray(0, 3209 /*isStatic=*/false, /*isStar=*/false, 3210 Size.get(), T.getOpenLocation(), 3211 T.getCloseLocation()), 3212 std::move(Attrs), T.getCloseLocation()); 3213 3214 if (T.getCloseLocation().isInvalid()) 3215 return; 3216 } 3217} 3218 3219/// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id. 3220/// This ambiguity appears in the syntax of the C++ new operator. 3221/// 3222/// new-expression: 3223/// '::'[opt] 'new' new-placement[opt] '(' type-id ')' 3224/// new-initializer[opt] 3225/// 3226/// new-placement: 3227/// '(' expression-list ')' 3228/// 3229bool Parser::ParseExpressionListOrTypeId( 3230 SmallVectorImpl<Expr*> &PlacementArgs, 3231 Declarator &D) { 3232 // The '(' was already consumed. 3233 if (isTypeIdInParens()) { 3234 ParseSpecifierQualifierList(D.getMutableDeclSpec()); 3235 D.SetSourceRange(D.getDeclSpec().getSourceRange()); 3236 ParseDeclarator(D); 3237 return D.isInvalidType(); 3238 } 3239 3240 // It's not a type, it has to be an expression list. 3241 // Discard the comma locations - ActOnCXXNew has enough parameters. 3242 CommaLocsTy CommaLocs; 3243 return ParseExpressionList(PlacementArgs, CommaLocs); 3244} 3245 3246/// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used 3247/// to free memory allocated by new. 3248/// 3249/// This method is called to parse the 'delete' expression after the optional 3250/// '::' has been already parsed. If the '::' was present, "UseGlobal" is true 3251/// and "Start" is its location. Otherwise, "Start" is the location of the 3252/// 'delete' token. 3253/// 3254/// delete-expression: 3255/// '::'[opt] 'delete' cast-expression 3256/// '::'[opt] 'delete' '[' ']' cast-expression 3257ExprResult 3258Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) { 3259 assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword"); 3260 ConsumeToken(); // Consume 'delete' 3261 3262 // Array delete? 3263 bool ArrayDelete = false; 3264 if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) { 3265 // C++11 [expr.delete]p1: 3266 // Whenever the delete keyword is followed by empty square brackets, it 3267 // shall be interpreted as [array delete]. 3268 // [Footnote: A lambda expression with a lambda-introducer that consists 3269 // of empty square brackets can follow the delete keyword if 3270 // the lambda expression is enclosed in parentheses.] 3271 3272 const Token Next = GetLookAheadToken(2); 3273 3274 // Basic lookahead to check if we have a lambda expression. 3275 if (Next.isOneOf(tok::l_brace, tok::less) || 3276 (Next.is(tok::l_paren) && 3277 (GetLookAheadToken(3).is(tok::r_paren) || 3278 (GetLookAheadToken(3).is(tok::identifier) && 3279 GetLookAheadToken(4).is(tok::identifier))))) { 3280 TentativeParsingAction TPA(*this); 3281 SourceLocation LSquareLoc = Tok.getLocation(); 3282 SourceLocation RSquareLoc = NextToken().getLocation(); 3283 3284 // SkipUntil can't skip pairs of </*...*/>; don't emit a FixIt in this 3285 // case. 3286 SkipUntil({tok::l_brace, tok::less}, StopBeforeMatch); 3287 SourceLocation RBraceLoc; 3288 bool EmitFixIt = false; 3289 if (Tok.is(tok::l_brace)) { 3290 ConsumeBrace(); 3291 SkipUntil(tok::r_brace, StopBeforeMatch); 3292 RBraceLoc = Tok.getLocation(); 3293 EmitFixIt = true; 3294 } 3295 3296 TPA.Revert(); 3297 3298 if (EmitFixIt) 3299 Diag(Start, diag::err_lambda_after_delete) 3300 << SourceRange(Start, RSquareLoc) 3301 << FixItHint::CreateInsertion(LSquareLoc, "(") 3302 << FixItHint::CreateInsertion( 3303 Lexer::getLocForEndOfToken( 3304 RBraceLoc, 0, Actions.getSourceManager(), getLangOpts()), 3305 ")"); 3306 else 3307 Diag(Start, diag::err_lambda_after_delete) 3308 << SourceRange(Start, RSquareLoc); 3309 3310 // Warn that the non-capturing lambda isn't surrounded by parentheses 3311 // to disambiguate it from 'delete[]'. 3312 ExprResult Lambda = ParseLambdaExpression(); 3313 if (Lambda.isInvalid()) 3314 return ExprError(); 3315 3316 // Evaluate any postfix expressions used on the lambda. 3317 Lambda = ParsePostfixExpressionSuffix(Lambda); 3318 if (Lambda.isInvalid()) 3319 return ExprError(); 3320 return Actions.ActOnCXXDelete(Start, UseGlobal, /*ArrayForm=*/false, 3321 Lambda.get()); 3322 } 3323 3324 ArrayDelete = true; 3325 BalancedDelimiterTracker T(*this, tok::l_square); 3326 3327 T.consumeOpen(); 3328 T.consumeClose(); 3329 if (T.getCloseLocation().isInvalid()) 3330 return ExprError(); 3331 } 3332 3333 ExprResult Operand(ParseCastExpression(AnyCastExpr)); 3334 if (Operand.isInvalid()) 3335 return Operand; 3336 3337 return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.get()); 3338} 3339 3340/// ParseRequiresExpression - Parse a C++2a requires-expression. 3341/// C++2a [expr.prim.req]p1 3342/// A requires-expression provides a concise way to express requirements on 3343/// template arguments. A requirement is one that can be checked by name 3344/// lookup (6.4) or by checking properties of types and expressions. 3345/// 3346/// requires-expression: 3347/// 'requires' requirement-parameter-list[opt] requirement-body 3348/// 3349/// requirement-parameter-list: 3350/// '(' parameter-declaration-clause[opt] ')' 3351/// 3352/// requirement-body: 3353/// '{' requirement-seq '}' 3354/// 3355/// requirement-seq: 3356/// requirement 3357/// requirement-seq requirement 3358/// 3359/// requirement: 3360/// simple-requirement 3361/// type-requirement 3362/// compound-requirement 3363/// nested-requirement 3364ExprResult Parser::ParseRequiresExpression() { 3365 assert(Tok.is(tok::kw_requires) && "Expected 'requires' keyword"); 3366 SourceLocation RequiresKWLoc = ConsumeToken(); // Consume 'requires' 3367 3368 llvm::SmallVector<ParmVarDecl *, 2> LocalParameterDecls; 3369 if (Tok.is(tok::l_paren)) { 3370 // requirement parameter list is present. 3371 ParseScope LocalParametersScope(this, Scope::FunctionPrototypeScope | 3372 Scope::DeclScope); 3373 BalancedDelimiterTracker Parens(*this, tok::l_paren); 3374 Parens.consumeOpen(); 3375 if (!Tok.is(tok::r_paren)) { 3376 ParsedAttributes FirstArgAttrs(getAttrFactory()); 3377 SourceLocation EllipsisLoc; 3378 llvm::SmallVector<DeclaratorChunk::ParamInfo, 2> LocalParameters; 3379 ParseParameterDeclarationClause(DeclaratorContext::RequiresExpr, 3380 FirstArgAttrs, LocalParameters, 3381 EllipsisLoc); 3382 if (EllipsisLoc.isValid()) 3383 Diag(EllipsisLoc, diag::err_requires_expr_parameter_list_ellipsis); 3384 for (auto &ParamInfo : LocalParameters) 3385 LocalParameterDecls.push_back(cast<ParmVarDecl>(ParamInfo.Param)); 3386 } 3387 Parens.consumeClose(); 3388 } 3389 3390 BalancedDelimiterTracker Braces(*this, tok::l_brace); 3391 if (Braces.expectAndConsume()) 3392 return ExprError(); 3393 3394 // Start of requirement list 3395 llvm::SmallVector<concepts::Requirement *, 2> Requirements; 3396 3397 // C++2a [expr.prim.req]p2 3398 // Expressions appearing within a requirement-body are unevaluated operands. 3399 EnterExpressionEvaluationContext Ctx( 3400 Actions, Sema::ExpressionEvaluationContext::Unevaluated); 3401 3402 ParseScope BodyScope(this, Scope::DeclScope); 3403 RequiresExprBodyDecl *Body = Actions.ActOnStartRequiresExpr( 3404 RequiresKWLoc, LocalParameterDecls, getCurScope()); 3405 3406 if (Tok.is(tok::r_brace)) { 3407 // Grammar does not allow an empty body. 3408 // requirement-body: 3409 // { requirement-seq } 3410 // requirement-seq: 3411 // requirement 3412 // requirement-seq requirement 3413 Diag(Tok, diag::err_empty_requires_expr); 3414 // Continue anyway and produce a requires expr with no requirements. 3415 } else { 3416 while (!Tok.is(tok::r_brace)) { 3417 switch (Tok.getKind()) { 3418 case tok::l_brace: { 3419 // Compound requirement 3420 // C++ [expr.prim.req.compound] 3421 // compound-requirement: 3422 // '{' expression '}' 'noexcept'[opt] 3423 // return-type-requirement[opt] ';' 3424 // return-type-requirement: 3425 // trailing-return-type 3426 // '->' cv-qualifier-seq[opt] constrained-parameter 3427 // cv-qualifier-seq[opt] abstract-declarator[opt] 3428 BalancedDelimiterTracker ExprBraces(*this, tok::l_brace); 3429 ExprBraces.consumeOpen(); 3430 ExprResult Expression = 3431 Actions.CorrectDelayedTyposInExpr(ParseExpression()); 3432 if (!Expression.isUsable()) { 3433 ExprBraces.skipToEnd(); 3434 SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); 3435 break; 3436 } 3437 if (ExprBraces.consumeClose()) 3438 ExprBraces.skipToEnd(); 3439 3440 concepts::Requirement *Req = nullptr; 3441 SourceLocation NoexceptLoc; 3442 TryConsumeToken(tok::kw_noexcept, NoexceptLoc); 3443 if (Tok.is(tok::semi)) { 3444 Req = Actions.ActOnCompoundRequirement(Expression.get(), NoexceptLoc); 3445 if (Req) 3446 Requirements.push_back(Req); 3447 break; 3448 } 3449 if (!TryConsumeToken(tok::arrow)) 3450 // User probably forgot the arrow, remind them and try to continue. 3451 Diag(Tok, diag::err_requires_expr_missing_arrow) 3452 << FixItHint::CreateInsertion(Tok.getLocation(), "->"); 3453 // Try to parse a 'type-constraint' 3454 if (TryAnnotateTypeConstraint()) { 3455 SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); 3456 break; 3457 } 3458 if (!isTypeConstraintAnnotation()) { 3459 Diag(Tok, diag::err_requires_expr_expected_type_constraint); 3460 SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); 3461 break; 3462 } 3463 CXXScopeSpec SS; 3464 if (Tok.is(tok::annot_cxxscope)) { 3465 Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(), 3466 Tok.getAnnotationRange(), 3467 SS); 3468 ConsumeAnnotationToken(); 3469 } 3470 3471 Req = Actions.ActOnCompoundRequirement( 3472 Expression.get(), NoexceptLoc, SS, takeTemplateIdAnnotation(Tok), 3473 TemplateParameterDepth); 3474 ConsumeAnnotationToken(); 3475 if (Req) 3476 Requirements.push_back(Req); 3477 break; 3478 } 3479 default: { 3480 bool PossibleRequiresExprInSimpleRequirement = false; 3481 if (Tok.is(tok::kw_requires)) { 3482 auto IsNestedRequirement = [&] { 3483 RevertingTentativeParsingAction TPA(*this); 3484 ConsumeToken(); // 'requires' 3485 if (Tok.is(tok::l_brace)) 3486 // This is a requires expression 3487 // requires (T t) { 3488 // requires { t++; }; 3489 // ... ^ 3490 // } 3491 return false; 3492 if (Tok.is(tok::l_paren)) { 3493 // This might be the parameter list of a requires expression 3494 ConsumeParen(); 3495 auto Res = TryParseParameterDeclarationClause(); 3496 if (Res != TPResult::False) { 3497 // Skip to the closing parenthesis 3498 // FIXME: Don't traverse these tokens twice (here and in 3499 // TryParseParameterDeclarationClause). 3500 unsigned Depth = 1; 3501 while (Depth != 0) { 3502 if (Tok.is(tok::l_paren)) 3503 Depth++; 3504 else if (Tok.is(tok::r_paren)) 3505 Depth--; 3506 ConsumeAnyToken(); 3507 } 3508 // requires (T t) { 3509 // requires () ? 3510 // ... ^ 3511 // - OR - 3512 // requires (int x) ? 3513 // ... ^ 3514 // } 3515 if (Tok.is(tok::l_brace)) 3516 // requires (...) { 3517 // ^ - a requires expression as a 3518 // simple-requirement. 3519 return false; 3520 } 3521 } 3522 return true; 3523 }; 3524 if (IsNestedRequirement()) { 3525 ConsumeToken(); 3526 // Nested requirement 3527 // C++ [expr.prim.req.nested] 3528 // nested-requirement: 3529 // 'requires' constraint-expression ';' 3530 ExprResult ConstraintExpr = 3531 Actions.CorrectDelayedTyposInExpr(ParseConstraintExpression()); 3532 if (ConstraintExpr.isInvalid() || !ConstraintExpr.isUsable()) { 3533 SkipUntil(tok::semi, tok::r_brace, 3534 SkipUntilFlags::StopBeforeMatch); 3535 break; 3536 } 3537 if (auto *Req = 3538 Actions.ActOnNestedRequirement(ConstraintExpr.get())) 3539 Requirements.push_back(Req); 3540 else { 3541 SkipUntil(tok::semi, tok::r_brace, 3542 SkipUntilFlags::StopBeforeMatch); 3543 break; 3544 } 3545 break; 3546 } else 3547 PossibleRequiresExprInSimpleRequirement = true; 3548 } else if (Tok.is(tok::kw_typename)) { 3549 // This might be 'typename T::value_type;' (a type requirement) or 3550 // 'typename T::value_type{};' (a simple requirement). 3551 TentativeParsingAction TPA(*this); 3552 3553 // We need to consume the typename to allow 'requires { typename a; }' 3554 SourceLocation TypenameKWLoc = ConsumeToken(); 3555 if (TryAnnotateCXXScopeToken()) { 3556 TPA.Commit(); 3557 SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); 3558 break; 3559 } 3560 CXXScopeSpec SS; 3561 if (Tok.is(tok::annot_cxxscope)) { 3562 Actions.RestoreNestedNameSpecifierAnnotation( 3563 Tok.getAnnotationValue(), Tok.getAnnotationRange(), SS); 3564 ConsumeAnnotationToken(); 3565 } 3566 3567 if (Tok.isOneOf(tok::identifier, tok::annot_template_id) && 3568 !NextToken().isOneOf(tok::l_brace, tok::l_paren)) { 3569 TPA.Commit(); 3570 SourceLocation NameLoc = Tok.getLocation(); 3571 IdentifierInfo *II = nullptr; 3572 TemplateIdAnnotation *TemplateId = nullptr; 3573 if (Tok.is(tok::identifier)) { 3574 II = Tok.getIdentifierInfo(); 3575 ConsumeToken(); 3576 } else { 3577 TemplateId = takeTemplateIdAnnotation(Tok); 3578 ConsumeAnnotationToken(); 3579 if (TemplateId->isInvalid()) 3580 break; 3581 } 3582 3583 if (auto *Req = Actions.ActOnTypeRequirement(TypenameKWLoc, SS, 3584 NameLoc, II, 3585 TemplateId)) { 3586 Requirements.push_back(Req); 3587 } 3588 break; 3589 } 3590 TPA.Revert(); 3591 } 3592 // Simple requirement 3593 // C++ [expr.prim.req.simple] 3594 // simple-requirement: 3595 // expression ';' 3596 SourceLocation StartLoc = Tok.getLocation(); 3597 ExprResult Expression = 3598 Actions.CorrectDelayedTyposInExpr(ParseExpression()); 3599 if (!Expression.isUsable()) { 3600 SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); 3601 break; 3602 } 3603 if (!Expression.isInvalid() && PossibleRequiresExprInSimpleRequirement) 3604 Diag(StartLoc, diag::warn_requires_expr_in_simple_requirement) 3605 << FixItHint::CreateInsertion(StartLoc, "requires"); 3606 if (auto *Req = Actions.ActOnSimpleRequirement(Expression.get())) 3607 Requirements.push_back(Req); 3608 else { 3609 SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); 3610 break; 3611 } 3612 // User may have tried to put some compound requirement stuff here 3613 if (Tok.is(tok::kw_noexcept)) { 3614 Diag(Tok, diag::err_requires_expr_simple_requirement_noexcept) 3615 << FixItHint::CreateInsertion(StartLoc, "{") 3616 << FixItHint::CreateInsertion(Tok.getLocation(), "}"); 3617 SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); 3618 break; 3619 } 3620 break; 3621 } 3622 } 3623 if (ExpectAndConsumeSemi(diag::err_expected_semi_requirement)) { 3624 SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); 3625 TryConsumeToken(tok::semi); 3626 break; 3627 } 3628 } 3629 if (Requirements.empty()) { 3630 // Don't emit an empty requires expr here to avoid confusing the user with 3631 // other diagnostics quoting an empty requires expression they never 3632 // wrote. 3633 Braces.consumeClose(); 3634 Actions.ActOnFinishRequiresExpr(); 3635 return ExprError(); 3636 } 3637 } 3638 Braces.consumeClose(); 3639 Actions.ActOnFinishRequiresExpr(); 3640 return Actions.ActOnRequiresExpr(RequiresKWLoc, Body, LocalParameterDecls, 3641 Requirements, Braces.getCloseLocation()); 3642} 3643 3644static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) { 3645 switch (kind) { 3646 default: llvm_unreachable("Not a known type trait"); 3647#define TYPE_TRAIT_1(Spelling, Name, Key) \ 3648case tok::kw_ ## Spelling: return UTT_ ## Name; 3649#define TYPE_TRAIT_2(Spelling, Name, Key) \ 3650case tok::kw_ ## Spelling: return BTT_ ## Name; 3651#include "clang/Basic/TokenKinds.def" 3652#define TYPE_TRAIT_N(Spelling, Name, Key) \ 3653 case tok::kw_ ## Spelling: return TT_ ## Name; 3654#include "clang/Basic/TokenKinds.def" 3655 } 3656} 3657 3658static ArrayTypeTrait ArrayTypeTraitFromTokKind(tok::TokenKind kind) { 3659 switch (kind) { 3660 default: 3661 llvm_unreachable("Not a known array type trait"); 3662#define ARRAY_TYPE_TRAIT(Spelling, Name, Key) \ 3663 case tok::kw_##Spelling: \ 3664 return ATT_##Name; 3665#include "clang/Basic/TokenKinds.def" 3666 } 3667} 3668 3669static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind) { 3670 switch (kind) { 3671 default: 3672 llvm_unreachable("Not a known unary expression trait."); 3673#define EXPRESSION_TRAIT(Spelling, Name, Key) \ 3674 case tok::kw_##Spelling: \ 3675 return ET_##Name; 3676#include "clang/Basic/TokenKinds.def" 3677 } 3678} 3679 3680static unsigned TypeTraitArity(tok::TokenKind kind) { 3681 switch (kind) { 3682 default: llvm_unreachable("Not a known type trait"); 3683#define TYPE_TRAIT(N,Spelling,K) case tok::kw_##Spelling: return N; 3684#include "clang/Basic/TokenKinds.def" 3685 } 3686} 3687 3688/// Parse the built-in type-trait pseudo-functions that allow 3689/// implementation of the TR1/C++11 type traits templates. 3690/// 3691/// primary-expression: 3692/// unary-type-trait '(' type-id ')' 3693/// binary-type-trait '(' type-id ',' type-id ')' 3694/// type-trait '(' type-id-seq ')' 3695/// 3696/// type-id-seq: 3697/// type-id ...[opt] type-id-seq[opt] 3698/// 3699ExprResult Parser::ParseTypeTrait() { 3700 tok::TokenKind Kind = Tok.getKind(); 3701 unsigned Arity = TypeTraitArity(Kind); 3702 3703 SourceLocation Loc = ConsumeToken(); 3704 3705 BalancedDelimiterTracker Parens(*this, tok::l_paren); 3706 if (Parens.expectAndConsume()) 3707 return ExprError(); 3708 3709 SmallVector<ParsedType, 2> Args; 3710 do { 3711 // Parse the next type. 3712 TypeResult Ty = ParseTypeName(); 3713 if (Ty.isInvalid()) { 3714 Parens.skipToEnd(); 3715 return ExprError(); 3716 } 3717 3718 // Parse the ellipsis, if present. 3719 if (Tok.is(tok::ellipsis)) { 3720 Ty = Actions.ActOnPackExpansion(Ty.get(), ConsumeToken()); 3721 if (Ty.isInvalid()) { 3722 Parens.skipToEnd(); 3723 return ExprError(); 3724 } 3725 } 3726 3727 // Add this type to the list of arguments. 3728 Args.push_back(Ty.get()); 3729 } while (TryConsumeToken(tok::comma)); 3730 3731 if (Parens.consumeClose()) 3732 return ExprError(); 3733 3734 SourceLocation EndLoc = Parens.getCloseLocation(); 3735 3736 if (Arity && Args.size() != Arity) { 3737 Diag(EndLoc, diag::err_type_trait_arity) 3738 << Arity << 0 << (Arity > 1) << (int)Args.size() << SourceRange(Loc); 3739 return ExprError(); 3740 } 3741 3742 if (!Arity && Args.empty()) { 3743 Diag(EndLoc, diag::err_type_trait_arity) 3744 << 1 << 1 << 1 << (int)Args.size() << SourceRange(Loc); 3745 return ExprError(); 3746 } 3747 3748 return Actions.ActOnTypeTrait(TypeTraitFromTokKind(Kind), Loc, Args, EndLoc); 3749} 3750 3751/// ParseArrayTypeTrait - Parse the built-in array type-trait 3752/// pseudo-functions. 3753/// 3754/// primary-expression: 3755/// [Embarcadero] '__array_rank' '(' type-id ')' 3756/// [Embarcadero] '__array_extent' '(' type-id ',' expression ')' 3757/// 3758ExprResult Parser::ParseArrayTypeTrait() { 3759 ArrayTypeTrait ATT = ArrayTypeTraitFromTokKind(Tok.getKind()); 3760 SourceLocation Loc = ConsumeToken(); 3761 3762 BalancedDelimiterTracker T(*this, tok::l_paren); 3763 if (T.expectAndConsume()) 3764 return ExprError(); 3765 3766 TypeResult Ty = ParseTypeName(); 3767 if (Ty.isInvalid()) { 3768 SkipUntil(tok::comma, StopAtSemi); 3769 SkipUntil(tok::r_paren, StopAtSemi); 3770 return ExprError(); 3771 } 3772 3773 switch (ATT) { 3774 case ATT_ArrayRank: { 3775 T.consumeClose(); 3776 return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), nullptr, 3777 T.getCloseLocation()); 3778 } 3779 case ATT_ArrayExtent: { 3780 if (ExpectAndConsume(tok::comma)) { 3781 SkipUntil(tok::r_paren, StopAtSemi); 3782 return ExprError(); 3783 } 3784 3785 ExprResult DimExpr = ParseExpression(); 3786 T.consumeClose(); 3787 3788 return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), DimExpr.get(), 3789 T.getCloseLocation()); 3790 } 3791 } 3792 llvm_unreachable("Invalid ArrayTypeTrait!"); 3793} 3794 3795/// ParseExpressionTrait - Parse built-in expression-trait 3796/// pseudo-functions like __is_lvalue_expr( xxx ). 3797/// 3798/// primary-expression: 3799/// [Embarcadero] expression-trait '(' expression ')' 3800/// 3801ExprResult Parser::ParseExpressionTrait() { 3802 ExpressionTrait ET = ExpressionTraitFromTokKind(Tok.getKind()); 3803 SourceLocation Loc = ConsumeToken(); 3804 3805 BalancedDelimiterTracker T(*this, tok::l_paren); 3806 if (T.expectAndConsume()) 3807 return ExprError(); 3808 3809 ExprResult Expr = ParseExpression(); 3810 3811 T.consumeClose(); 3812 3813 return Actions.ActOnExpressionTrait(ET, Loc, Expr.get(), 3814 T.getCloseLocation()); 3815} 3816 3817 3818/// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a 3819/// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate 3820/// based on the context past the parens. 3821ExprResult 3822Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType, 3823 ParsedType &CastTy, 3824 BalancedDelimiterTracker &Tracker, 3825 ColonProtectionRAIIObject &ColonProt) { 3826 assert(getLangOpts().CPlusPlus && "Should only be called for C++!"); 3827 assert(ExprType == CastExpr && "Compound literals are not ambiguous!"); 3828 assert(isTypeIdInParens() && "Not a type-id!"); 3829 3830 ExprResult Result(true); 3831 CastTy = nullptr; 3832 3833 // We need to disambiguate a very ugly part of the C++ syntax: 3834 // 3835 // (T())x; - type-id 3836 // (T())*x; - type-id 3837 // (T())/x; - expression 3838 // (T()); - expression 3839 // 3840 // The bad news is that we cannot use the specialized tentative parser, since 3841 // it can only verify that the thing inside the parens can be parsed as 3842 // type-id, it is not useful for determining the context past the parens. 3843 // 3844 // The good news is that the parser can disambiguate this part without 3845 // making any unnecessary Action calls. 3846 // 3847 // It uses a scheme similar to parsing inline methods. The parenthesized 3848 // tokens are cached, the context that follows is determined (possibly by 3849 // parsing a cast-expression), and then we re-introduce the cached tokens 3850 // into the token stream and parse them appropriately. 3851 3852 ParenParseOption ParseAs; 3853 CachedTokens Toks; 3854 3855 // Store the tokens of the parentheses. We will parse them after we determine 3856 // the context that follows them. 3857 if (!ConsumeAndStoreUntil(tok::r_paren, Toks)) { 3858 // We didn't find the ')' we expected. 3859 Tracker.consumeClose(); 3860 return ExprError(); 3861 } 3862 3863 if (Tok.is(tok::l_brace)) { 3864 ParseAs = CompoundLiteral; 3865 } else { 3866 bool NotCastExpr; 3867 if (Tok.is(tok::l_paren) && NextToken().is(tok::r_paren)) { 3868 NotCastExpr = true; 3869 } else { 3870 // Try parsing the cast-expression that may follow. 3871 // If it is not a cast-expression, NotCastExpr will be true and no token 3872 // will be consumed. 3873 ColonProt.restore(); 3874 Result = ParseCastExpression(AnyCastExpr, 3875 false/*isAddressofOperand*/, 3876 NotCastExpr, 3877 // type-id has priority. 3878 IsTypeCast); 3879 } 3880 3881 // If we parsed a cast-expression, it's really a type-id, otherwise it's 3882 // an expression. 3883 ParseAs = NotCastExpr ? SimpleExpr : CastExpr; 3884 } 3885 3886 // Create a fake EOF to mark end of Toks buffer. 3887 Token AttrEnd; 3888 AttrEnd.startToken(); 3889 AttrEnd.setKind(tok::eof); 3890 AttrEnd.setLocation(Tok.getLocation()); 3891 AttrEnd.setEofData(Toks.data()); 3892 Toks.push_back(AttrEnd); 3893 3894 // The current token should go after the cached tokens. 3895 Toks.push_back(Tok); 3896 // Re-enter the stored parenthesized tokens into the token stream, so we may 3897 // parse them now. 3898 PP.EnterTokenStream(Toks, /*DisableMacroExpansion*/ true, 3899 /*IsReinject*/ true); 3900 // Drop the current token and bring the first cached one. It's the same token 3901 // as when we entered this function. 3902 ConsumeAnyToken(); 3903 3904 if (ParseAs >= CompoundLiteral) { 3905 // Parse the type declarator. 3906 DeclSpec DS(AttrFactory); 3907 Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName); 3908 { 3909 ColonProtectionRAIIObject InnerColonProtection(*this); 3910 ParseSpecifierQualifierList(DS); 3911 ParseDeclarator(DeclaratorInfo); 3912 } 3913 3914 // Match the ')'. 3915 Tracker.consumeClose(); 3916 ColonProt.restore(); 3917 3918 // Consume EOF marker for Toks buffer. 3919 assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData()); 3920 ConsumeAnyToken(); 3921 3922 if (ParseAs == CompoundLiteral) { 3923 ExprType = CompoundLiteral; 3924 if (DeclaratorInfo.isInvalidType()) 3925 return ExprError(); 3926 3927 TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo); 3928 return ParseCompoundLiteralExpression(Ty.get(), 3929 Tracker.getOpenLocation(), 3930 Tracker.getCloseLocation()); 3931 } 3932 3933 // We parsed '(' type-id ')' and the thing after it wasn't a '{'. 3934 assert(ParseAs == CastExpr); 3935 3936 if (DeclaratorInfo.isInvalidType()) 3937 return ExprError(); 3938 3939 // Result is what ParseCastExpression returned earlier. 3940 if (!Result.isInvalid()) 3941 Result = Actions.ActOnCastExpr(getCurScope(), Tracker.getOpenLocation(), 3942 DeclaratorInfo, CastTy, 3943 Tracker.getCloseLocation(), Result.get()); 3944 return Result; 3945 } 3946 3947 // Not a compound literal, and not followed by a cast-expression. 3948 assert(ParseAs == SimpleExpr); 3949 3950 ExprType = SimpleExpr; 3951 Result = ParseExpression(); 3952 if (!Result.isInvalid() && Tok.is(tok::r_paren)) 3953 Result = Actions.ActOnParenExpr(Tracker.getOpenLocation(), 3954 Tok.getLocation(), Result.get()); 3955 3956 // Match the ')'. 3957 if (Result.isInvalid()) { 3958 while (Tok.isNot(tok::eof)) 3959 ConsumeAnyToken(); 3960 assert(Tok.getEofData() == AttrEnd.getEofData()); 3961 ConsumeAnyToken(); 3962 return ExprError(); 3963 } 3964 3965 Tracker.consumeClose(); 3966 // Consume EOF marker for Toks buffer. 3967 assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData()); 3968 ConsumeAnyToken(); 3969 return Result; 3970} 3971 3972/// Parse a __builtin_bit_cast(T, E). 3973ExprResult Parser::ParseBuiltinBitCast() { 3974 SourceLocation KWLoc = ConsumeToken(); 3975 3976 BalancedDelimiterTracker T(*this, tok::l_paren); 3977 if (T.expectAndConsume(diag::err_expected_lparen_after, "__builtin_bit_cast")) 3978 return ExprError(); 3979 3980 // Parse the common declaration-specifiers piece. 3981 DeclSpec DS(AttrFactory); 3982 ParseSpecifierQualifierList(DS); 3983 3984 // Parse the abstract-declarator, if present. 3985 Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName); 3986 ParseDeclarator(DeclaratorInfo); 3987 3988 if (ExpectAndConsume(tok::comma)) { 3989 Diag(Tok.getLocation(), diag::err_expected) << tok::comma; 3990 SkipUntil(tok::r_paren, StopAtSemi); 3991 return ExprError(); 3992 } 3993 3994 ExprResult Operand = ParseExpression(); 3995 3996 if (T.consumeClose()) 3997 return ExprError(); 3998 3999 if (Operand.isInvalid() || DeclaratorInfo.isInvalidType()) 4000 return ExprError(); 4001 4002 return Actions.ActOnBuiltinBitCastExpr(KWLoc, DeclaratorInfo, Operand, 4003 T.getCloseLocation()); 4004} 4005