1//===--- ParseCXXInlineMethods.cpp - C++ class inline methods parsing------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements parsing for C++ class inline methods. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Parse/Parser.h" 15#include "RAIIObjectsForParser.h" 16#include "clang/AST/DeclTemplate.h" 17#include "clang/Parse/ParseDiagnostic.h" 18#include "clang/Sema/DeclSpec.h" 19#include "clang/Sema/Scope.h" 20using namespace clang; 21 22/// Get the FunctionDecl for a function or function template decl. 23static FunctionDecl *getFunctionDecl(Decl *D) { 24 if (FunctionDecl *fn = dyn_cast<FunctionDecl>(D)) 25 return fn; 26 return cast<FunctionTemplateDecl>(D)->getTemplatedDecl(); 27} 28 29/// ParseCXXInlineMethodDef - We parsed and verified that the specified 30/// Declarator is a well formed C++ inline method definition. Now lex its body 31/// and store its tokens for parsing after the C++ class is complete. 32NamedDecl *Parser::ParseCXXInlineMethodDef(AccessSpecifier AS, 33 AttributeList *AccessAttrs, 34 ParsingDeclarator &D, 35 const ParsedTemplateInfo &TemplateInfo, 36 const VirtSpecifiers& VS, 37 FunctionDefinitionKind DefinitionKind, 38 ExprResult& Init) { 39 assert(D.isFunctionDeclarator() && "This isn't a function declarator!"); 40 assert((Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try) || 41 Tok.is(tok::equal)) && 42 "Current token not a '{', ':', '=', or 'try'!"); 43 44 MultiTemplateParamsArg TemplateParams( 45 TemplateInfo.TemplateParams ? TemplateInfo.TemplateParams->data() : 0, 46 TemplateInfo.TemplateParams ? TemplateInfo.TemplateParams->size() : 0); 47 48 NamedDecl *FnD; 49 D.setFunctionDefinitionKind(DefinitionKind); 50 if (D.getDeclSpec().isFriendSpecified()) 51 FnD = Actions.ActOnFriendFunctionDecl(getCurScope(), D, 52 TemplateParams); 53 else { 54 FnD = Actions.ActOnCXXMemberDeclarator(getCurScope(), AS, D, 55 TemplateParams, 0, 56 VS, ICIS_NoInit); 57 if (FnD) { 58 Actions.ProcessDeclAttributeList(getCurScope(), FnD, AccessAttrs); 59 bool TypeSpecContainsAuto = D.getDeclSpec().containsPlaceholderType(); 60 if (Init.isUsable()) 61 Actions.AddInitializerToDecl(FnD, Init.get(), false, 62 TypeSpecContainsAuto); 63 else 64 Actions.ActOnUninitializedDecl(FnD, TypeSpecContainsAuto); 65 } 66 } 67 68 HandleMemberFunctionDeclDelays(D, FnD); 69 70 D.complete(FnD); 71 72 if (Tok.is(tok::equal)) { 73 ConsumeToken(); 74 75 if (!FnD) { 76 SkipUntil(tok::semi); 77 return 0; 78 } 79 80 bool Delete = false; 81 SourceLocation KWLoc; 82 if (Tok.is(tok::kw_delete)) { 83 Diag(Tok, getLangOpts().CPlusPlus11 ? 84 diag::warn_cxx98_compat_deleted_function : 85 diag::ext_deleted_function); 86 87 KWLoc = ConsumeToken(); 88 Actions.SetDeclDeleted(FnD, KWLoc); 89 Delete = true; 90 } else if (Tok.is(tok::kw_default)) { 91 Diag(Tok, getLangOpts().CPlusPlus11 ? 92 diag::warn_cxx98_compat_defaulted_function : 93 diag::ext_defaulted_function); 94 95 KWLoc = ConsumeToken(); 96 Actions.SetDeclDefaulted(FnD, KWLoc); 97 } else { 98 llvm_unreachable("function definition after = not 'delete' or 'default'"); 99 } 100 101 if (Tok.is(tok::comma)) { 102 Diag(KWLoc, diag::err_default_delete_in_multiple_declaration) 103 << Delete; 104 SkipUntil(tok::semi); 105 } else { 106 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, 107 Delete ? "delete" : "default", tok::semi); 108 } 109 110 return FnD; 111 } 112 113 // In delayed template parsing mode, if we are within a class template 114 // or if we are about to parse function member template then consume 115 // the tokens and store them for parsing at the end of the translation unit. 116 if (getLangOpts().DelayedTemplateParsing && 117 DefinitionKind == FDK_Definition && 118 !D.getDeclSpec().isConstexprSpecified() && 119 !(FnD && getFunctionDecl(FnD) && 120 getFunctionDecl(FnD)->getResultType()->getContainedAutoType()) && 121 ((Actions.CurContext->isDependentContext() || 122 (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate && 123 TemplateInfo.Kind != ParsedTemplateInfo::ExplicitSpecialization)) && 124 !Actions.IsInsideALocalClassWithinATemplateFunction())) { 125 126 CachedTokens Toks; 127 LexTemplateFunctionForLateParsing(Toks); 128 129 if (FnD) { 130 FunctionDecl *FD = getFunctionDecl(FnD); 131 Actions.CheckForFunctionRedefinition(FD); 132 Actions.MarkAsLateParsedTemplate(FD, FnD, Toks); 133 } 134 135 return FnD; 136 } 137 138 // Consume the tokens and store them for later parsing. 139 140 LexedMethod* LM = new LexedMethod(this, FnD); 141 getCurrentClass().LateParsedDeclarations.push_back(LM); 142 LM->TemplateScope = getCurScope()->isTemplateParamScope(); 143 CachedTokens &Toks = LM->Toks; 144 145 tok::TokenKind kind = Tok.getKind(); 146 // Consume everything up to (and including) the left brace of the 147 // function body. 148 if (ConsumeAndStoreFunctionPrologue(Toks)) { 149 // We didn't find the left-brace we expected after the 150 // constructor initializer; we already printed an error, and it's likely 151 // impossible to recover, so don't try to parse this method later. 152 // Skip over the rest of the decl and back to somewhere that looks 153 // reasonable. 154 SkipMalformedDecl(); 155 delete getCurrentClass().LateParsedDeclarations.back(); 156 getCurrentClass().LateParsedDeclarations.pop_back(); 157 return FnD; 158 } else { 159 // Consume everything up to (and including) the matching right brace. 160 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false); 161 } 162 163 // If we're in a function-try-block, we need to store all the catch blocks. 164 if (kind == tok::kw_try) { 165 while (Tok.is(tok::kw_catch)) { 166 ConsumeAndStoreUntil(tok::l_brace, Toks, /*StopAtSemi=*/false); 167 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false); 168 } 169 } 170 171 if (FnD) { 172 // If this is a friend function, mark that it's late-parsed so that 173 // it's still known to be a definition even before we attach the 174 // parsed body. Sema needs to treat friend function definitions 175 // differently during template instantiation, and it's possible for 176 // the containing class to be instantiated before all its member 177 // function definitions are parsed. 178 // 179 // If you remove this, you can remove the code that clears the flag 180 // after parsing the member. 181 if (D.getDeclSpec().isFriendSpecified()) { 182 FunctionDecl *FD = getFunctionDecl(FnD); 183 Actions.CheckForFunctionRedefinition(FD); 184 FD->setLateTemplateParsed(true); 185 } 186 } else { 187 // If semantic analysis could not build a function declaration, 188 // just throw away the late-parsed declaration. 189 delete getCurrentClass().LateParsedDeclarations.back(); 190 getCurrentClass().LateParsedDeclarations.pop_back(); 191 } 192 193 return FnD; 194} 195 196/// ParseCXXNonStaticMemberInitializer - We parsed and verified that the 197/// specified Declarator is a well formed C++ non-static data member 198/// declaration. Now lex its initializer and store its tokens for parsing 199/// after the class is complete. 200void Parser::ParseCXXNonStaticMemberInitializer(Decl *VarD) { 201 assert((Tok.is(tok::l_brace) || Tok.is(tok::equal)) && 202 "Current token not a '{' or '='!"); 203 204 LateParsedMemberInitializer *MI = 205 new LateParsedMemberInitializer(this, VarD); 206 getCurrentClass().LateParsedDeclarations.push_back(MI); 207 CachedTokens &Toks = MI->Toks; 208 209 tok::TokenKind kind = Tok.getKind(); 210 if (kind == tok::equal) { 211 Toks.push_back(Tok); 212 ConsumeToken(); 213 } 214 215 if (kind == tok::l_brace) { 216 // Begin by storing the '{' token. 217 Toks.push_back(Tok); 218 ConsumeBrace(); 219 220 // Consume everything up to (and including) the matching right brace. 221 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/true); 222 } else { 223 // Consume everything up to (but excluding) the comma or semicolon. 224 ConsumeAndStoreInitializer(Toks, CIK_DefaultInitializer); 225 } 226 227 // Store an artificial EOF token to ensure that we don't run off the end of 228 // the initializer when we come to parse it. 229 Token Eof; 230 Eof.startToken(); 231 Eof.setKind(tok::eof); 232 Eof.setLocation(Tok.getLocation()); 233 Toks.push_back(Eof); 234} 235 236Parser::LateParsedDeclaration::~LateParsedDeclaration() {} 237void Parser::LateParsedDeclaration::ParseLexedMethodDeclarations() {} 238void Parser::LateParsedDeclaration::ParseLexedMemberInitializers() {} 239void Parser::LateParsedDeclaration::ParseLexedMethodDefs() {} 240 241Parser::LateParsedClass::LateParsedClass(Parser *P, ParsingClass *C) 242 : Self(P), Class(C) {} 243 244Parser::LateParsedClass::~LateParsedClass() { 245 Self->DeallocateParsedClasses(Class); 246} 247 248void Parser::LateParsedClass::ParseLexedMethodDeclarations() { 249 Self->ParseLexedMethodDeclarations(*Class); 250} 251 252void Parser::LateParsedClass::ParseLexedMemberInitializers() { 253 Self->ParseLexedMemberInitializers(*Class); 254} 255 256void Parser::LateParsedClass::ParseLexedMethodDefs() { 257 Self->ParseLexedMethodDefs(*Class); 258} 259 260void Parser::LateParsedMethodDeclaration::ParseLexedMethodDeclarations() { 261 Self->ParseLexedMethodDeclaration(*this); 262} 263 264void Parser::LexedMethod::ParseLexedMethodDefs() { 265 Self->ParseLexedMethodDef(*this); 266} 267 268void Parser::LateParsedMemberInitializer::ParseLexedMemberInitializers() { 269 Self->ParseLexedMemberInitializer(*this); 270} 271 272/// ParseLexedMethodDeclarations - We finished parsing the member 273/// specification of a top (non-nested) C++ class. Now go over the 274/// stack of method declarations with some parts for which parsing was 275/// delayed (such as default arguments) and parse them. 276void Parser::ParseLexedMethodDeclarations(ParsingClass &Class) { 277 bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope; 278 ParseScope ClassTemplateScope(this, Scope::TemplateParamScope, HasTemplateScope); 279 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth); 280 if (HasTemplateScope) { 281 Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate); 282 ++CurTemplateDepthTracker; 283 } 284 285 // The current scope is still active if we're the top-level class. 286 // Otherwise we'll need to push and enter a new scope. 287 bool HasClassScope = !Class.TopLevelClass; 288 ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope, 289 HasClassScope); 290 if (HasClassScope) 291 Actions.ActOnStartDelayedMemberDeclarations(getCurScope(), Class.TagOrTemplate); 292 293 for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) { 294 Class.LateParsedDeclarations[i]->ParseLexedMethodDeclarations(); 295 } 296 297 if (HasClassScope) 298 Actions.ActOnFinishDelayedMemberDeclarations(getCurScope(), Class.TagOrTemplate); 299} 300 301void Parser::ParseLexedMethodDeclaration(LateParsedMethodDeclaration &LM) { 302 // If this is a member template, introduce the template parameter scope. 303 ParseScope TemplateScope(this, Scope::TemplateParamScope, LM.TemplateScope); 304 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth); 305 if (LM.TemplateScope) { 306 Actions.ActOnReenterTemplateScope(getCurScope(), LM.Method); 307 ++CurTemplateDepthTracker; 308 } 309 // Start the delayed C++ method declaration 310 Actions.ActOnStartDelayedCXXMethodDeclaration(getCurScope(), LM.Method); 311 312 // Introduce the parameters into scope and parse their default 313 // arguments. 314 ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope | 315 Scope::FunctionDeclarationScope | Scope::DeclScope); 316 for (unsigned I = 0, N = LM.DefaultArgs.size(); I != N; ++I) { 317 // Introduce the parameter into scope. 318 Actions.ActOnDelayedCXXMethodParameter(getCurScope(), 319 LM.DefaultArgs[I].Param); 320 321 if (CachedTokens *Toks = LM.DefaultArgs[I].Toks) { 322 // Save the current token position. 323 SourceLocation origLoc = Tok.getLocation(); 324 325 // Parse the default argument from its saved token stream. 326 Toks->push_back(Tok); // So that the current token doesn't get lost 327 PP.EnterTokenStream(&Toks->front(), Toks->size(), true, false); 328 329 // Consume the previously-pushed token. 330 ConsumeAnyToken(); 331 332 // Consume the '='. 333 assert(Tok.is(tok::equal) && "Default argument not starting with '='"); 334 SourceLocation EqualLoc = ConsumeToken(); 335 336 // The argument isn't actually potentially evaluated unless it is 337 // used. 338 EnterExpressionEvaluationContext Eval(Actions, 339 Sema::PotentiallyEvaluatedIfUsed, 340 LM.DefaultArgs[I].Param); 341 342 ExprResult DefArgResult; 343 if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) { 344 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists); 345 DefArgResult = ParseBraceInitializer(); 346 } else 347 DefArgResult = ParseAssignmentExpression(); 348 if (DefArgResult.isInvalid()) 349 Actions.ActOnParamDefaultArgumentError(LM.DefaultArgs[I].Param); 350 else { 351 if (Tok.is(tok::cxx_defaultarg_end)) 352 ConsumeToken(); 353 else { 354 // The last two tokens are the terminator and the saved value of 355 // Tok; the last token in the default argument is the one before 356 // those. 357 assert(Toks->size() >= 3 && "expected a token in default arg"); 358 Diag(Tok.getLocation(), diag::err_default_arg_unparsed) 359 << SourceRange(Tok.getLocation(), 360 (*Toks)[Toks->size() - 3].getLocation()); 361 } 362 Actions.ActOnParamDefaultArgument(LM.DefaultArgs[I].Param, EqualLoc, 363 DefArgResult.take()); 364 } 365 366 assert(!PP.getSourceManager().isBeforeInTranslationUnit(origLoc, 367 Tok.getLocation()) && 368 "ParseAssignmentExpression went over the default arg tokens!"); 369 // There could be leftover tokens (e.g. because of an error). 370 // Skip through until we reach the original token position. 371 while (Tok.getLocation() != origLoc && Tok.isNot(tok::eof)) 372 ConsumeAnyToken(); 373 374 delete Toks; 375 LM.DefaultArgs[I].Toks = 0; 376 } 377 } 378 379 PrototypeScope.Exit(); 380 381 // Finish the delayed C++ method declaration. 382 Actions.ActOnFinishDelayedCXXMethodDeclaration(getCurScope(), LM.Method); 383} 384 385/// ParseLexedMethodDefs - We finished parsing the member specification of a top 386/// (non-nested) C++ class. Now go over the stack of lexed methods that were 387/// collected during its parsing and parse them all. 388void Parser::ParseLexedMethodDefs(ParsingClass &Class) { 389 bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope; 390 ParseScope ClassTemplateScope(this, Scope::TemplateParamScope, HasTemplateScope); 391 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth); 392 if (HasTemplateScope) { 393 Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate); 394 ++CurTemplateDepthTracker; 395 } 396 bool HasClassScope = !Class.TopLevelClass; 397 ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope, 398 HasClassScope); 399 400 for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) { 401 Class.LateParsedDeclarations[i]->ParseLexedMethodDefs(); 402 } 403} 404 405void Parser::ParseLexedMethodDef(LexedMethod &LM) { 406 // If this is a member template, introduce the template parameter scope. 407 ParseScope TemplateScope(this, Scope::TemplateParamScope, LM.TemplateScope); 408 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth); 409 if (LM.TemplateScope) { 410 Actions.ActOnReenterTemplateScope(getCurScope(), LM.D); 411 ++CurTemplateDepthTracker; 412 } 413 // Save the current token position. 414 SourceLocation origLoc = Tok.getLocation(); 415 416 assert(!LM.Toks.empty() && "Empty body!"); 417 // Append the current token at the end of the new token stream so that it 418 // doesn't get lost. 419 LM.Toks.push_back(Tok); 420 PP.EnterTokenStream(LM.Toks.data(), LM.Toks.size(), true, false); 421 422 // Consume the previously pushed token. 423 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true); 424 assert((Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try)) 425 && "Inline method not starting with '{', ':' or 'try'"); 426 427 // Parse the method body. Function body parsing code is similar enough 428 // to be re-used for method bodies as well. 429 ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope); 430 Actions.ActOnStartOfFunctionDef(getCurScope(), LM.D); 431 432 if (Tok.is(tok::kw_try)) { 433 ParseFunctionTryBlock(LM.D, FnScope); 434 assert(!PP.getSourceManager().isBeforeInTranslationUnit(origLoc, 435 Tok.getLocation()) && 436 "ParseFunctionTryBlock went over the cached tokens!"); 437 // There could be leftover tokens (e.g. because of an error). 438 // Skip through until we reach the original token position. 439 while (Tok.getLocation() != origLoc && Tok.isNot(tok::eof)) 440 ConsumeAnyToken(); 441 return; 442 } 443 if (Tok.is(tok::colon)) { 444 ParseConstructorInitializer(LM.D); 445 446 // Error recovery. 447 if (!Tok.is(tok::l_brace)) { 448 FnScope.Exit(); 449 Actions.ActOnFinishFunctionBody(LM.D, 0); 450 while (Tok.getLocation() != origLoc && Tok.isNot(tok::eof)) 451 ConsumeAnyToken(); 452 return; 453 } 454 } else 455 Actions.ActOnDefaultCtorInitializers(LM.D); 456 457 assert((Actions.getDiagnostics().hasErrorOccurred() || 458 !isa<FunctionTemplateDecl>(LM.D) || 459 cast<FunctionTemplateDecl>(LM.D)->getTemplateParameters()->getDepth() 460 < TemplateParameterDepth) && 461 "TemplateParameterDepth should be greater than the depth of " 462 "current template being instantiated!"); 463 464 ParseFunctionStatementBody(LM.D, FnScope); 465 466 // Clear the late-template-parsed bit if we set it before. 467 if (LM.D) getFunctionDecl(LM.D)->setLateTemplateParsed(false); 468 469 if (Tok.getLocation() != origLoc) { 470 // Due to parsing error, we either went over the cached tokens or 471 // there are still cached tokens left. If it's the latter case skip the 472 // leftover tokens. 473 // Since this is an uncommon situation that should be avoided, use the 474 // expensive isBeforeInTranslationUnit call. 475 if (PP.getSourceManager().isBeforeInTranslationUnit(Tok.getLocation(), 476 origLoc)) 477 while (Tok.getLocation() != origLoc && Tok.isNot(tok::eof)) 478 ConsumeAnyToken(); 479 } 480} 481 482/// ParseLexedMemberInitializers - We finished parsing the member specification 483/// of a top (non-nested) C++ class. Now go over the stack of lexed data member 484/// initializers that were collected during its parsing and parse them all. 485void Parser::ParseLexedMemberInitializers(ParsingClass &Class) { 486 bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope; 487 ParseScope ClassTemplateScope(this, Scope::TemplateParamScope, 488 HasTemplateScope); 489 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth); 490 if (HasTemplateScope) { 491 Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate); 492 ++CurTemplateDepthTracker; 493 } 494 // Set or update the scope flags. 495 bool AlreadyHasClassScope = Class.TopLevelClass; 496 unsigned ScopeFlags = Scope::ClassScope|Scope::DeclScope; 497 ParseScope ClassScope(this, ScopeFlags, !AlreadyHasClassScope); 498 ParseScopeFlags ClassScopeFlags(this, ScopeFlags, AlreadyHasClassScope); 499 500 if (!AlreadyHasClassScope) 501 Actions.ActOnStartDelayedMemberDeclarations(getCurScope(), 502 Class.TagOrTemplate); 503 504 if (!Class.LateParsedDeclarations.empty()) { 505 // C++11 [expr.prim.general]p4: 506 // Otherwise, if a member-declarator declares a non-static data member 507 // (9.2) of a class X, the expression this is a prvalue of type "pointer 508 // to X" within the optional brace-or-equal-initializer. It shall not 509 // appear elsewhere in the member-declarator. 510 Sema::CXXThisScopeRAII ThisScope(Actions, Class.TagOrTemplate, 511 /*TypeQuals=*/(unsigned)0); 512 513 for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) { 514 Class.LateParsedDeclarations[i]->ParseLexedMemberInitializers(); 515 } 516 } 517 518 if (!AlreadyHasClassScope) 519 Actions.ActOnFinishDelayedMemberDeclarations(getCurScope(), 520 Class.TagOrTemplate); 521 522 Actions.ActOnFinishDelayedMemberInitializers(Class.TagOrTemplate); 523} 524 525void Parser::ParseLexedMemberInitializer(LateParsedMemberInitializer &MI) { 526 if (!MI.Field || MI.Field->isInvalidDecl()) 527 return; 528 529 // Append the current token at the end of the new token stream so that it 530 // doesn't get lost. 531 MI.Toks.push_back(Tok); 532 PP.EnterTokenStream(MI.Toks.data(), MI.Toks.size(), true, false); 533 534 // Consume the previously pushed token. 535 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true); 536 537 SourceLocation EqualLoc; 538 539 ExprResult Init = ParseCXXMemberInitializer(MI.Field, /*IsFunction=*/false, 540 EqualLoc); 541 542 Actions.ActOnCXXInClassMemberInitializer(MI.Field, EqualLoc, Init.release()); 543 544 // The next token should be our artificial terminating EOF token. 545 if (Tok.isNot(tok::eof)) { 546 SourceLocation EndLoc = PP.getLocForEndOfToken(PrevTokLocation); 547 if (!EndLoc.isValid()) 548 EndLoc = Tok.getLocation(); 549 // No fixit; we can't recover as if there were a semicolon here. 550 Diag(EndLoc, diag::err_expected_semi_decl_list); 551 552 // Consume tokens until we hit the artificial EOF. 553 while (Tok.isNot(tok::eof)) 554 ConsumeAnyToken(); 555 } 556 ConsumeAnyToken(); 557} 558 559/// ConsumeAndStoreUntil - Consume and store the token at the passed token 560/// container until the token 'T' is reached (which gets 561/// consumed/stored too, if ConsumeFinalToken). 562/// If StopAtSemi is true, then we will stop early at a ';' character. 563/// Returns true if token 'T1' or 'T2' was found. 564/// NOTE: This is a specialized version of Parser::SkipUntil. 565bool Parser::ConsumeAndStoreUntil(tok::TokenKind T1, tok::TokenKind T2, 566 CachedTokens &Toks, 567 bool StopAtSemi, bool ConsumeFinalToken) { 568 // We always want this function to consume at least one token if the first 569 // token isn't T and if not at EOF. 570 bool isFirstTokenConsumed = true; 571 while (1) { 572 // If we found one of the tokens, stop and return true. 573 if (Tok.is(T1) || Tok.is(T2)) { 574 if (ConsumeFinalToken) { 575 Toks.push_back(Tok); 576 ConsumeAnyToken(); 577 } 578 return true; 579 } 580 581 switch (Tok.getKind()) { 582 case tok::eof: 583 // Ran out of tokens. 584 return false; 585 586 case tok::l_paren: 587 // Recursively consume properly-nested parens. 588 Toks.push_back(Tok); 589 ConsumeParen(); 590 ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false); 591 break; 592 case tok::l_square: 593 // Recursively consume properly-nested square brackets. 594 Toks.push_back(Tok); 595 ConsumeBracket(); 596 ConsumeAndStoreUntil(tok::r_square, Toks, /*StopAtSemi=*/false); 597 break; 598 case tok::l_brace: 599 // Recursively consume properly-nested braces. 600 Toks.push_back(Tok); 601 ConsumeBrace(); 602 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false); 603 break; 604 605 // Okay, we found a ']' or '}' or ')', which we think should be balanced. 606 // Since the user wasn't looking for this token (if they were, it would 607 // already be handled), this isn't balanced. If there is a LHS token at a 608 // higher level, we will assume that this matches the unbalanced token 609 // and return it. Otherwise, this is a spurious RHS token, which we skip. 610 case tok::r_paren: 611 if (ParenCount && !isFirstTokenConsumed) 612 return false; // Matches something. 613 Toks.push_back(Tok); 614 ConsumeParen(); 615 break; 616 case tok::r_square: 617 if (BracketCount && !isFirstTokenConsumed) 618 return false; // Matches something. 619 Toks.push_back(Tok); 620 ConsumeBracket(); 621 break; 622 case tok::r_brace: 623 if (BraceCount && !isFirstTokenConsumed) 624 return false; // Matches something. 625 Toks.push_back(Tok); 626 ConsumeBrace(); 627 break; 628 629 case tok::code_completion: 630 Toks.push_back(Tok); 631 ConsumeCodeCompletionToken(); 632 break; 633 634 case tok::string_literal: 635 case tok::wide_string_literal: 636 case tok::utf8_string_literal: 637 case tok::utf16_string_literal: 638 case tok::utf32_string_literal: 639 Toks.push_back(Tok); 640 ConsumeStringToken(); 641 break; 642 case tok::semi: 643 if (StopAtSemi) 644 return false; 645 // FALL THROUGH. 646 default: 647 // consume this token. 648 Toks.push_back(Tok); 649 ConsumeToken(); 650 break; 651 } 652 isFirstTokenConsumed = false; 653 } 654} 655 656/// \brief Consume tokens and store them in the passed token container until 657/// we've passed the try keyword and constructor initializers and have consumed 658/// the opening brace of the function body. The opening brace will be consumed 659/// if and only if there was no error. 660/// 661/// \return True on error. 662bool Parser::ConsumeAndStoreFunctionPrologue(CachedTokens &Toks) { 663 if (Tok.is(tok::kw_try)) { 664 Toks.push_back(Tok); 665 ConsumeToken(); 666 } 667 668 if (Tok.isNot(tok::colon)) { 669 // Easy case, just a function body. 670 671 // Grab any remaining garbage to be diagnosed later. We stop when we reach a 672 // brace: an opening one is the function body, while a closing one probably 673 // means we've reached the end of the class. 674 ConsumeAndStoreUntil(tok::l_brace, tok::r_brace, Toks, 675 /*StopAtSemi=*/true, 676 /*ConsumeFinalToken=*/false); 677 if (Tok.isNot(tok::l_brace)) 678 return Diag(Tok.getLocation(), diag::err_expected_lbrace); 679 680 Toks.push_back(Tok); 681 ConsumeBrace(); 682 return false; 683 } 684 685 Toks.push_back(Tok); 686 ConsumeToken(); 687 688 // We can't reliably skip over a mem-initializer-id, because it could be 689 // a template-id involving not-yet-declared names. Given: 690 // 691 // S ( ) : a < b < c > ( e ) 692 // 693 // 'e' might be an initializer or part of a template argument, depending 694 // on whether 'b' is a template. 695 696 // Track whether we might be inside a template argument. We can give 697 // significantly better diagnostics if we know that we're not. 698 bool MightBeTemplateArgument = false; 699 700 while (true) { 701 // Skip over the mem-initializer-id, if possible. 702 if (Tok.is(tok::kw_decltype)) { 703 Toks.push_back(Tok); 704 SourceLocation OpenLoc = ConsumeToken(); 705 if (Tok.isNot(tok::l_paren)) 706 return Diag(Tok.getLocation(), diag::err_expected_lparen_after) 707 << "decltype"; 708 Toks.push_back(Tok); 709 ConsumeParen(); 710 if (!ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/true)) { 711 Diag(Tok.getLocation(), diag::err_expected_rparen); 712 Diag(OpenLoc, diag::note_matching) << "("; 713 return true; 714 } 715 } 716 do { 717 // Walk over a component of a nested-name-specifier. 718 if (Tok.is(tok::coloncolon)) { 719 Toks.push_back(Tok); 720 ConsumeToken(); 721 722 if (Tok.is(tok::kw_template)) { 723 Toks.push_back(Tok); 724 ConsumeToken(); 725 } 726 } 727 728 if (Tok.is(tok::identifier) || Tok.is(tok::kw_template)) { 729 Toks.push_back(Tok); 730 ConsumeToken(); 731 } else if (Tok.is(tok::code_completion)) { 732 Toks.push_back(Tok); 733 ConsumeCodeCompletionToken(); 734 // Consume the rest of the initializers permissively. 735 // FIXME: We should be able to perform code-completion here even if 736 // there isn't a subsequent '{' token. 737 MightBeTemplateArgument = true; 738 break; 739 } else { 740 break; 741 } 742 } while (Tok.is(tok::coloncolon)); 743 744 if (Tok.is(tok::less)) 745 MightBeTemplateArgument = true; 746 747 if (MightBeTemplateArgument) { 748 // We may be inside a template argument list. Grab up to the start of the 749 // next parenthesized initializer or braced-init-list. This *might* be the 750 // initializer, or it might be a subexpression in the template argument 751 // list. 752 // FIXME: Count angle brackets, and clear MightBeTemplateArgument 753 // if all angles are closed. 754 if (!ConsumeAndStoreUntil(tok::l_paren, tok::l_brace, Toks, 755 /*StopAtSemi=*/true, 756 /*ConsumeFinalToken=*/false)) { 757 // We're not just missing the initializer, we're also missing the 758 // function body! 759 return Diag(Tok.getLocation(), diag::err_expected_lbrace); 760 } 761 } else if (Tok.isNot(tok::l_paren) && Tok.isNot(tok::l_brace)) { 762 // We found something weird in a mem-initializer-id. 763 return Diag(Tok.getLocation(), getLangOpts().CPlusPlus11 764 ? diag::err_expected_lparen_or_lbrace 765 : diag::err_expected_lparen); 766 } 767 768 tok::TokenKind kind = Tok.getKind(); 769 Toks.push_back(Tok); 770 bool IsLParen = (kind == tok::l_paren); 771 SourceLocation OpenLoc = Tok.getLocation(); 772 773 if (IsLParen) { 774 ConsumeParen(); 775 } else { 776 assert(kind == tok::l_brace && "Must be left paren or brace here."); 777 ConsumeBrace(); 778 // In C++03, this has to be the start of the function body, which 779 // means the initializer is malformed; we'll diagnose it later. 780 if (!getLangOpts().CPlusPlus11) 781 return false; 782 } 783 784 // Grab the initializer (or the subexpression of the template argument). 785 // FIXME: If we support lambdas here, we'll need to set StopAtSemi to false 786 // if we might be inside the braces of a lambda-expression. 787 if (!ConsumeAndStoreUntil(IsLParen ? tok::r_paren : tok::r_brace, 788 Toks, /*StopAtSemi=*/true)) { 789 Diag(Tok, IsLParen ? diag::err_expected_rparen : 790 diag::err_expected_rbrace); 791 Diag(OpenLoc, diag::note_matching) << (IsLParen ? "(" : "{"); 792 return true; 793 } 794 795 // Grab pack ellipsis, if present. 796 if (Tok.is(tok::ellipsis)) { 797 Toks.push_back(Tok); 798 ConsumeToken(); 799 } 800 801 // If we know we just consumed a mem-initializer, we must have ',' or '{' 802 // next. 803 if (Tok.is(tok::comma)) { 804 Toks.push_back(Tok); 805 ConsumeToken(); 806 } else if (Tok.is(tok::l_brace)) { 807 // This is the function body if the ')' or '}' is immediately followed by 808 // a '{'. That cannot happen within a template argument, apart from the 809 // case where a template argument contains a compound literal: 810 // 811 // S ( ) : a < b < c > ( d ) { } 812 // // End of declaration, or still inside the template argument? 813 // 814 // ... and the case where the template argument contains a lambda: 815 // 816 // S ( ) : a < 0 && b < c > ( d ) + [ ] ( ) { return 0; } 817 // ( ) > ( ) { } 818 // 819 // FIXME: Disambiguate these cases. Note that the latter case is probably 820 // going to be made ill-formed by core issue 1607. 821 Toks.push_back(Tok); 822 ConsumeBrace(); 823 return false; 824 } else if (!MightBeTemplateArgument) { 825 return Diag(Tok.getLocation(), diag::err_expected_lbrace_or_comma); 826 } 827 } 828} 829 830/// \brief Consume and store tokens from the '?' to the ':' in a conditional 831/// expression. 832bool Parser::ConsumeAndStoreConditional(CachedTokens &Toks) { 833 // Consume '?'. 834 assert(Tok.is(tok::question)); 835 Toks.push_back(Tok); 836 ConsumeToken(); 837 838 while (Tok.isNot(tok::colon)) { 839 if (!ConsumeAndStoreUntil(tok::question, tok::colon, Toks, /*StopAtSemi*/true, 840 /*ConsumeFinalToken*/false)) 841 return false; 842 843 // If we found a nested conditional, consume it. 844 if (Tok.is(tok::question) && !ConsumeAndStoreConditional(Toks)) 845 return false; 846 } 847 848 // Consume ':'. 849 Toks.push_back(Tok); 850 ConsumeToken(); 851 return true; 852} 853 854/// \brief A tentative parsing action that can also revert token annotations. 855class Parser::UnannotatedTentativeParsingAction : public TentativeParsingAction { 856public: 857 explicit UnannotatedTentativeParsingAction(Parser &Self, 858 tok::TokenKind EndKind) 859 : TentativeParsingAction(Self), Self(Self), EndKind(EndKind) { 860 // Stash away the old token stream, so we can restore it once the 861 // tentative parse is complete. 862 TentativeParsingAction Inner(Self); 863 Self.ConsumeAndStoreUntil(EndKind, Toks, true, /*ConsumeFinalToken*/false); 864 Inner.Revert(); 865 } 866 867 void RevertAnnotations() { 868 Revert(); 869 870 // Put back the original tokens. 871 Self.SkipUntil(EndKind, StopAtSemi | StopBeforeMatch); 872 if (Toks.size()) { 873 Token *Buffer = new Token[Toks.size()]; 874 std::copy(Toks.begin() + 1, Toks.end(), Buffer); 875 Buffer[Toks.size() - 1] = Self.Tok; 876 Self.PP.EnterTokenStream(Buffer, Toks.size(), true, /*Owned*/true); 877 878 Self.Tok = Toks.front(); 879 } 880 } 881 882private: 883 Parser &Self; 884 CachedTokens Toks; 885 tok::TokenKind EndKind; 886}; 887 888/// ConsumeAndStoreInitializer - Consume and store the token at the passed token 889/// container until the end of the current initializer expression (either a 890/// default argument or an in-class initializer for a non-static data member). 891/// The final token is not consumed. 892bool Parser::ConsumeAndStoreInitializer(CachedTokens &Toks, 893 CachedInitKind CIK) { 894 // We always want this function to consume at least one token if not at EOF. 895 bool IsFirstTokenConsumed = true; 896 897 // Number of possible unclosed <s we've seen so far. These might be templates, 898 // and might not, but if there were none of them (or we know for sure that 899 // we're within a template), we can avoid a tentative parse. 900 unsigned AngleCount = 0; 901 unsigned KnownTemplateCount = 0; 902 903 while (1) { 904 switch (Tok.getKind()) { 905 case tok::comma: 906 // If we might be in a template, perform a tentative parse to check. 907 if (!AngleCount) 908 // Not a template argument: this is the end of the initializer. 909 return true; 910 if (KnownTemplateCount) 911 goto consume_token; 912 913 // We hit a comma inside angle brackets. This is the hard case. The 914 // rule we follow is: 915 // * For a default argument, if the tokens after the comma form a 916 // syntactically-valid parameter-declaration-clause, in which each 917 // parameter has an initializer, then this comma ends the default 918 // argument. 919 // * For a default initializer, if the tokens after the comma form a 920 // syntactically-valid init-declarator-list, then this comma ends 921 // the default initializer. 922 { 923 UnannotatedTentativeParsingAction PA(*this, 924 CIK == CIK_DefaultInitializer 925 ? tok::semi : tok::r_paren); 926 Sema::TentativeAnalysisScope Scope(Actions); 927 928 TPResult Result = TPResult::Error(); 929 ConsumeToken(); 930 switch (CIK) { 931 case CIK_DefaultInitializer: 932 Result = TryParseInitDeclaratorList(); 933 // If we parsed a complete, ambiguous init-declarator-list, this 934 // is only syntactically-valid if it's followed by a semicolon. 935 if (Result == TPResult::Ambiguous() && Tok.isNot(tok::semi)) 936 Result = TPResult::False(); 937 break; 938 939 case CIK_DefaultArgument: 940 bool InvalidAsDeclaration = false; 941 Result = TryParseParameterDeclarationClause( 942 &InvalidAsDeclaration, /*VersusTemplateArgument*/true); 943 // If this is an expression or a declaration with a missing 944 // 'typename', assume it's not a declaration. 945 if (Result == TPResult::Ambiguous() && InvalidAsDeclaration) 946 Result = TPResult::False(); 947 break; 948 } 949 950 // If what follows could be a declaration, it is a declaration. 951 if (Result != TPResult::False() && Result != TPResult::Error()) { 952 PA.Revert(); 953 return true; 954 } 955 956 // In the uncommon case that we decide the following tokens are part 957 // of a template argument, revert any annotations we've performed in 958 // those tokens. We're not going to look them up until we've parsed 959 // the rest of the class, and that might add more declarations. 960 PA.RevertAnnotations(); 961 } 962 963 // Keep going. We know we're inside a template argument list now. 964 ++KnownTemplateCount; 965 goto consume_token; 966 967 case tok::eof: 968 // Ran out of tokens. 969 return false; 970 971 case tok::less: 972 // FIXME: A '<' can only start a template-id if it's preceded by an 973 // identifier, an operator-function-id, or a literal-operator-id. 974 ++AngleCount; 975 goto consume_token; 976 977 case tok::question: 978 // In 'a ? b : c', 'b' can contain an unparenthesized comma. If it does, 979 // that is *never* the end of the initializer. Skip to the ':'. 980 if (!ConsumeAndStoreConditional(Toks)) 981 return false; 982 break; 983 984 case tok::greatergreatergreater: 985 if (!getLangOpts().CPlusPlus11) 986 goto consume_token; 987 if (AngleCount) --AngleCount; 988 if (KnownTemplateCount) --KnownTemplateCount; 989 // Fall through. 990 case tok::greatergreater: 991 if (!getLangOpts().CPlusPlus11) 992 goto consume_token; 993 if (AngleCount) --AngleCount; 994 if (KnownTemplateCount) --KnownTemplateCount; 995 // Fall through. 996 case tok::greater: 997 if (AngleCount) --AngleCount; 998 if (KnownTemplateCount) --KnownTemplateCount; 999 goto consume_token; 1000 1001 case tok::kw_template: 1002 // 'template' identifier '<' is known to start a template argument list, 1003 // and can be used to disambiguate the parse. 1004 // FIXME: Support all forms of 'template' unqualified-id '<'. 1005 Toks.push_back(Tok); 1006 ConsumeToken(); 1007 if (Tok.is(tok::identifier)) { 1008 Toks.push_back(Tok); 1009 ConsumeToken(); 1010 if (Tok.is(tok::less)) { 1011 ++KnownTemplateCount; 1012 Toks.push_back(Tok); 1013 ConsumeToken(); 1014 } 1015 } 1016 break; 1017 1018 case tok::kw_operator: 1019 // If 'operator' precedes other punctuation, that punctuation loses 1020 // its special behavior. 1021 Toks.push_back(Tok); 1022 ConsumeToken(); 1023 switch (Tok.getKind()) { 1024 case tok::comma: 1025 case tok::greatergreatergreater: 1026 case tok::greatergreater: 1027 case tok::greater: 1028 case tok::less: 1029 Toks.push_back(Tok); 1030 ConsumeToken(); 1031 break; 1032 default: 1033 break; 1034 } 1035 break; 1036 1037 case tok::l_paren: 1038 // Recursively consume properly-nested parens. 1039 Toks.push_back(Tok); 1040 ConsumeParen(); 1041 ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false); 1042 break; 1043 case tok::l_square: 1044 // Recursively consume properly-nested square brackets. 1045 Toks.push_back(Tok); 1046 ConsumeBracket(); 1047 ConsumeAndStoreUntil(tok::r_square, Toks, /*StopAtSemi=*/false); 1048 break; 1049 case tok::l_brace: 1050 // Recursively consume properly-nested braces. 1051 Toks.push_back(Tok); 1052 ConsumeBrace(); 1053 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false); 1054 break; 1055 1056 // Okay, we found a ']' or '}' or ')', which we think should be balanced. 1057 // Since the user wasn't looking for this token (if they were, it would 1058 // already be handled), this isn't balanced. If there is a LHS token at a 1059 // higher level, we will assume that this matches the unbalanced token 1060 // and return it. Otherwise, this is a spurious RHS token, which we skip. 1061 case tok::r_paren: 1062 if (CIK == CIK_DefaultArgument) 1063 return true; // End of the default argument. 1064 if (ParenCount && !IsFirstTokenConsumed) 1065 return false; // Matches something. 1066 goto consume_token; 1067 case tok::r_square: 1068 if (BracketCount && !IsFirstTokenConsumed) 1069 return false; // Matches something. 1070 goto consume_token; 1071 case tok::r_brace: 1072 if (BraceCount && !IsFirstTokenConsumed) 1073 return false; // Matches something. 1074 goto consume_token; 1075 1076 case tok::code_completion: 1077 Toks.push_back(Tok); 1078 ConsumeCodeCompletionToken(); 1079 break; 1080 1081 case tok::string_literal: 1082 case tok::wide_string_literal: 1083 case tok::utf8_string_literal: 1084 case tok::utf16_string_literal: 1085 case tok::utf32_string_literal: 1086 Toks.push_back(Tok); 1087 ConsumeStringToken(); 1088 break; 1089 case tok::semi: 1090 if (CIK == CIK_DefaultInitializer) 1091 return true; // End of the default initializer. 1092 // FALL THROUGH. 1093 default: 1094 consume_token: 1095 Toks.push_back(Tok); 1096 ConsumeToken(); 1097 break; 1098 } 1099 IsFirstTokenConsumed = false; 1100 } 1101} 1102