ParseCXXInlineMethods.cpp revision 259065
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 false, true); 60 bool TypeSpecContainsAuto = D.getDeclSpec().containsPlaceholderType(); 61 if (Init.isUsable()) 62 Actions.AddInitializerToDecl(FnD, Init.get(), false, 63 TypeSpecContainsAuto); 64 else 65 Actions.ActOnUninitializedDecl(FnD, TypeSpecContainsAuto); 66 } 67 } 68 69 HandleMemberFunctionDeclDelays(D, FnD); 70 71 D.complete(FnD); 72 73 if (Tok.is(tok::equal)) { 74 ConsumeToken(); 75 76 if (!FnD) { 77 SkipUntil(tok::semi); 78 return 0; 79 } 80 81 bool Delete = false; 82 SourceLocation KWLoc; 83 if (Tok.is(tok::kw_delete)) { 84 Diag(Tok, getLangOpts().CPlusPlus11 ? 85 diag::warn_cxx98_compat_deleted_function : 86 diag::ext_deleted_function); 87 88 KWLoc = ConsumeToken(); 89 Actions.SetDeclDeleted(FnD, KWLoc); 90 Delete = true; 91 } else if (Tok.is(tok::kw_default)) { 92 Diag(Tok, getLangOpts().CPlusPlus11 ? 93 diag::warn_cxx98_compat_defaulted_function : 94 diag::ext_defaulted_function); 95 96 KWLoc = ConsumeToken(); 97 Actions.SetDeclDefaulted(FnD, KWLoc); 98 } else { 99 llvm_unreachable("function definition after = not 'delete' or 'default'"); 100 } 101 102 if (Tok.is(tok::comma)) { 103 Diag(KWLoc, diag::err_default_delete_in_multiple_declaration) 104 << Delete; 105 SkipUntil(tok::semi); 106 } else { 107 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, 108 Delete ? "delete" : "default", tok::semi); 109 } 110 111 return FnD; 112 } 113 114 // In delayed template parsing mode, if we are within a class template 115 // or if we are about to parse function member template then consume 116 // the tokens and store them for parsing at the end of the translation unit. 117 if (getLangOpts().DelayedTemplateParsing && 118 DefinitionKind == FDK_Definition && 119 ((Actions.CurContext->isDependentContext() || 120 TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate) && 121 !Actions.IsInsideALocalClassWithinATemplateFunction())) { 122 123 if (FnD) { 124 LateParsedTemplatedFunction *LPT = new LateParsedTemplatedFunction(FnD); 125 126 FunctionDecl *FD = getFunctionDecl(FnD); 127 Actions.CheckForFunctionRedefinition(FD); 128 129 LateParsedTemplateMap[FD] = LPT; 130 Actions.MarkAsLateParsedTemplate(FD); 131 LexTemplateFunctionForLateParsing(LPT->Toks); 132 } else { 133 CachedTokens Toks; 134 LexTemplateFunctionForLateParsing(Toks); 135 } 136 137 return FnD; 138 } 139 140 // Consume the tokens and store them for later parsing. 141 142 LexedMethod* LM = new LexedMethod(this, FnD); 143 getCurrentClass().LateParsedDeclarations.push_back(LM); 144 LM->TemplateScope = getCurScope()->isTemplateParamScope(); 145 CachedTokens &Toks = LM->Toks; 146 147 tok::TokenKind kind = Tok.getKind(); 148 // Consume everything up to (and including) the left brace of the 149 // function body. 150 if (ConsumeAndStoreFunctionPrologue(Toks)) { 151 // We didn't find the left-brace we expected after the 152 // constructor initializer; we already printed an error, and it's likely 153 // impossible to recover, so don't try to parse this method later. 154 // If we stopped at a semicolon, consume it to avoid an extra warning. 155 if (Tok.is(tok::semi)) 156 ConsumeToken(); 157 delete getCurrentClass().LateParsedDeclarations.back(); 158 getCurrentClass().LateParsedDeclarations.pop_back(); 159 return FnD; 160 } else { 161 // Consume everything up to (and including) the matching right brace. 162 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false); 163 } 164 165 // If we're in a function-try-block, we need to store all the catch blocks. 166 if (kind == tok::kw_try) { 167 while (Tok.is(tok::kw_catch)) { 168 ConsumeAndStoreUntil(tok::l_brace, Toks, /*StopAtSemi=*/false); 169 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false); 170 } 171 } 172 173 174 if (!FnD) { 175 // If semantic analysis could not build a function declaration, 176 // just throw away the late-parsed declaration. 177 delete getCurrentClass().LateParsedDeclarations.back(); 178 getCurrentClass().LateParsedDeclarations.pop_back(); 179 } 180 181 // If this is a friend function, mark that it's late-parsed so that 182 // it's still known to be a definition even before we attach the 183 // parsed body. Sema needs to treat friend function definitions 184 // differently during template instantiation, and it's possible for 185 // the containing class to be instantiated before all its member 186 // function definitions are parsed. 187 // 188 // If you remove this, you can remove the code that clears the flag 189 // after parsing the member. 190 if (D.getDeclSpec().isFriendSpecified()) { 191 getFunctionDecl(FnD)->setLateTemplateParsed(true); 192 } 193 194 return FnD; 195} 196 197/// ParseCXXNonStaticMemberInitializer - We parsed and verified that the 198/// specified Declarator is a well formed C++ non-static data member 199/// declaration. Now lex its initializer and store its tokens for parsing 200/// after the class is complete. 201void Parser::ParseCXXNonStaticMemberInitializer(Decl *VarD) { 202 assert((Tok.is(tok::l_brace) || Tok.is(tok::equal)) && 203 "Current token not a '{' or '='!"); 204 205 LateParsedMemberInitializer *MI = 206 new LateParsedMemberInitializer(this, VarD); 207 getCurrentClass().LateParsedDeclarations.push_back(MI); 208 CachedTokens &Toks = MI->Toks; 209 210 tok::TokenKind kind = Tok.getKind(); 211 if (kind == tok::equal) { 212 Toks.push_back(Tok); 213 ConsumeToken(); 214 } 215 216 if (kind == tok::l_brace) { 217 // Begin by storing the '{' token. 218 Toks.push_back(Tok); 219 ConsumeBrace(); 220 221 // Consume everything up to (and including) the matching right brace. 222 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/true); 223 } else { 224 // Consume everything up to (but excluding) the comma or semicolon. 225 ConsumeAndStoreUntil(tok::comma, Toks, /*StopAtSemi=*/true, 226 /*ConsumeFinalToken=*/false); 227 } 228 229 // Store an artificial EOF token to ensure that we don't run off the end of 230 // the initializer when we come to parse it. 231 Token Eof; 232 Eof.startToken(); 233 Eof.setKind(tok::eof); 234 Eof.setLocation(Tok.getLocation()); 235 Toks.push_back(Eof); 236} 237 238Parser::LateParsedDeclaration::~LateParsedDeclaration() {} 239void Parser::LateParsedDeclaration::ParseLexedMethodDeclarations() {} 240void Parser::LateParsedDeclaration::ParseLexedMemberInitializers() {} 241void Parser::LateParsedDeclaration::ParseLexedMethodDefs() {} 242 243Parser::LateParsedClass::LateParsedClass(Parser *P, ParsingClass *C) 244 : Self(P), Class(C) {} 245 246Parser::LateParsedClass::~LateParsedClass() { 247 Self->DeallocateParsedClasses(Class); 248} 249 250void Parser::LateParsedClass::ParseLexedMethodDeclarations() { 251 Self->ParseLexedMethodDeclarations(*Class); 252} 253 254void Parser::LateParsedClass::ParseLexedMemberInitializers() { 255 Self->ParseLexedMemberInitializers(*Class); 256} 257 258void Parser::LateParsedClass::ParseLexedMethodDefs() { 259 Self->ParseLexedMethodDefs(*Class); 260} 261 262void Parser::LateParsedMethodDeclaration::ParseLexedMethodDeclarations() { 263 Self->ParseLexedMethodDeclaration(*this); 264} 265 266void Parser::LexedMethod::ParseLexedMethodDefs() { 267 Self->ParseLexedMethodDef(*this); 268} 269 270void Parser::LateParsedMemberInitializer::ParseLexedMemberInitializers() { 271 Self->ParseLexedMemberInitializer(*this); 272} 273 274/// ParseLexedMethodDeclarations - We finished parsing the member 275/// specification of a top (non-nested) C++ class. Now go over the 276/// stack of method declarations with some parts for which parsing was 277/// delayed (such as default arguments) and parse them. 278void Parser::ParseLexedMethodDeclarations(ParsingClass &Class) { 279 bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope; 280 ParseScope ClassTemplateScope(this, Scope::TemplateParamScope, HasTemplateScope); 281 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth); 282 if (HasTemplateScope) { 283 Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate); 284 ++CurTemplateDepthTracker; 285 } 286 287 // The current scope is still active if we're the top-level class. 288 // Otherwise we'll need to push and enter a new scope. 289 bool HasClassScope = !Class.TopLevelClass; 290 ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope, 291 HasClassScope); 292 if (HasClassScope) 293 Actions.ActOnStartDelayedMemberDeclarations(getCurScope(), Class.TagOrTemplate); 294 295 for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) { 296 Class.LateParsedDeclarations[i]->ParseLexedMethodDeclarations(); 297 } 298 299 if (HasClassScope) 300 Actions.ActOnFinishDelayedMemberDeclarations(getCurScope(), Class.TagOrTemplate); 301} 302 303void Parser::ParseLexedMethodDeclaration(LateParsedMethodDeclaration &LM) { 304 // If this is a member template, introduce the template parameter scope. 305 ParseScope TemplateScope(this, Scope::TemplateParamScope, LM.TemplateScope); 306 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth); 307 if (LM.TemplateScope) { 308 Actions.ActOnReenterTemplateScope(getCurScope(), LM.Method); 309 ++CurTemplateDepthTracker; 310 } 311 // Start the delayed C++ method declaration 312 Actions.ActOnStartDelayedCXXMethodDeclaration(getCurScope(), LM.Method); 313 314 // Introduce the parameters into scope and parse their default 315 // arguments. 316 ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope | 317 Scope::FunctionDeclarationScope | Scope::DeclScope); 318 for (unsigned I = 0, N = LM.DefaultArgs.size(); I != N; ++I) { 319 // Introduce the parameter into scope. 320 Actions.ActOnDelayedCXXMethodParameter(getCurScope(), 321 LM.DefaultArgs[I].Param); 322 323 if (CachedTokens *Toks = LM.DefaultArgs[I].Toks) { 324 // Save the current token position. 325 SourceLocation origLoc = Tok.getLocation(); 326 327 // Parse the default argument from its saved token stream. 328 Toks->push_back(Tok); // So that the current token doesn't get lost 329 PP.EnterTokenStream(&Toks->front(), Toks->size(), true, false); 330 331 // Consume the previously-pushed token. 332 ConsumeAnyToken(); 333 334 // Consume the '='. 335 assert(Tok.is(tok::equal) && "Default argument not starting with '='"); 336 SourceLocation EqualLoc = ConsumeToken(); 337 338 // The argument isn't actually potentially evaluated unless it is 339 // used. 340 EnterExpressionEvaluationContext Eval(Actions, 341 Sema::PotentiallyEvaluatedIfUsed, 342 LM.DefaultArgs[I].Param); 343 344 ExprResult DefArgResult; 345 if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) { 346 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists); 347 DefArgResult = ParseBraceInitializer(); 348 } else 349 DefArgResult = ParseAssignmentExpression(); 350 if (DefArgResult.isInvalid()) 351 Actions.ActOnParamDefaultArgumentError(LM.DefaultArgs[I].Param); 352 else { 353 if (Tok.is(tok::cxx_defaultarg_end)) 354 ConsumeToken(); 355 else 356 Diag(Tok.getLocation(), diag::err_default_arg_unparsed); 357 Actions.ActOnParamDefaultArgument(LM.DefaultArgs[I].Param, EqualLoc, 358 DefArgResult.take()); 359 } 360 361 assert(!PP.getSourceManager().isBeforeInTranslationUnit(origLoc, 362 Tok.getLocation()) && 363 "ParseAssignmentExpression went over the default arg tokens!"); 364 // There could be leftover tokens (e.g. because of an error). 365 // Skip through until we reach the original token position. 366 while (Tok.getLocation() != origLoc && Tok.isNot(tok::eof)) 367 ConsumeAnyToken(); 368 369 delete Toks; 370 LM.DefaultArgs[I].Toks = 0; 371 } 372 } 373 374 PrototypeScope.Exit(); 375 376 // Finish the delayed C++ method declaration. 377 Actions.ActOnFinishDelayedCXXMethodDeclaration(getCurScope(), LM.Method); 378} 379 380/// ParseLexedMethodDefs - We finished parsing the member specification of a top 381/// (non-nested) C++ class. Now go over the stack of lexed methods that were 382/// collected during its parsing and parse them all. 383void Parser::ParseLexedMethodDefs(ParsingClass &Class) { 384 bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope; 385 ParseScope ClassTemplateScope(this, Scope::TemplateParamScope, HasTemplateScope); 386 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth); 387 if (HasTemplateScope) { 388 Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate); 389 ++CurTemplateDepthTracker; 390 } 391 bool HasClassScope = !Class.TopLevelClass; 392 ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope, 393 HasClassScope); 394 395 for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) { 396 Class.LateParsedDeclarations[i]->ParseLexedMethodDefs(); 397 } 398} 399 400void Parser::ParseLexedMethodDef(LexedMethod &LM) { 401 // If this is a member template, introduce the template parameter scope. 402 ParseScope TemplateScope(this, Scope::TemplateParamScope, LM.TemplateScope); 403 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth); 404 if (LM.TemplateScope) { 405 Actions.ActOnReenterTemplateScope(getCurScope(), LM.D); 406 ++CurTemplateDepthTracker; 407 } 408 // Save the current token position. 409 SourceLocation origLoc = Tok.getLocation(); 410 411 assert(!LM.Toks.empty() && "Empty body!"); 412 // Append the current token at the end of the new token stream so that it 413 // doesn't get lost. 414 LM.Toks.push_back(Tok); 415 PP.EnterTokenStream(LM.Toks.data(), LM.Toks.size(), true, false); 416 417 // Consume the previously pushed token. 418 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true); 419 assert((Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try)) 420 && "Inline method not starting with '{', ':' or 'try'"); 421 422 // Parse the method body. Function body parsing code is similar enough 423 // to be re-used for method bodies as well. 424 ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope); 425 Actions.ActOnStartOfFunctionDef(getCurScope(), LM.D); 426 427 if (Tok.is(tok::kw_try)) { 428 ParseFunctionTryBlock(LM.D, FnScope); 429 assert(!PP.getSourceManager().isBeforeInTranslationUnit(origLoc, 430 Tok.getLocation()) && 431 "ParseFunctionTryBlock went over the cached tokens!"); 432 // There could be leftover tokens (e.g. because of an error). 433 // Skip through until we reach the original token position. 434 while (Tok.getLocation() != origLoc && Tok.isNot(tok::eof)) 435 ConsumeAnyToken(); 436 return; 437 } 438 if (Tok.is(tok::colon)) { 439 ParseConstructorInitializer(LM.D); 440 441 // Error recovery. 442 if (!Tok.is(tok::l_brace)) { 443 FnScope.Exit(); 444 Actions.ActOnFinishFunctionBody(LM.D, 0); 445 while (Tok.getLocation() != origLoc && Tok.isNot(tok::eof)) 446 ConsumeAnyToken(); 447 return; 448 } 449 } else 450 Actions.ActOnDefaultCtorInitializers(LM.D); 451 452 assert((Actions.getDiagnostics().hasErrorOccurred() || 453 !isa<FunctionTemplateDecl>(LM.D) || 454 cast<FunctionTemplateDecl>(LM.D)->getTemplateParameters()->getDepth() 455 < TemplateParameterDepth) && 456 "TemplateParameterDepth should be greater than the depth of " 457 "current template being instantiated!"); 458 459 ParseFunctionStatementBody(LM.D, FnScope); 460 461 // Clear the late-template-parsed bit if we set it before. 462 if (LM.D) getFunctionDecl(LM.D)->setLateTemplateParsed(false); 463 464 if (Tok.getLocation() != origLoc) { 465 // Due to parsing error, we either went over the cached tokens or 466 // there are still cached tokens left. If it's the latter case skip the 467 // leftover tokens. 468 // Since this is an uncommon situation that should be avoided, use the 469 // expensive isBeforeInTranslationUnit call. 470 if (PP.getSourceManager().isBeforeInTranslationUnit(Tok.getLocation(), 471 origLoc)) 472 while (Tok.getLocation() != origLoc && Tok.isNot(tok::eof)) 473 ConsumeAnyToken(); 474 } 475} 476 477/// ParseLexedMemberInitializers - We finished parsing the member specification 478/// of a top (non-nested) C++ class. Now go over the stack of lexed data member 479/// initializers that were collected during its parsing and parse them all. 480void Parser::ParseLexedMemberInitializers(ParsingClass &Class) { 481 bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope; 482 ParseScope ClassTemplateScope(this, Scope::TemplateParamScope, 483 HasTemplateScope); 484 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth); 485 if (HasTemplateScope) { 486 Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate); 487 ++CurTemplateDepthTracker; 488 } 489 // Set or update the scope flags. 490 bool AlreadyHasClassScope = Class.TopLevelClass; 491 unsigned ScopeFlags = Scope::ClassScope|Scope::DeclScope; 492 ParseScope ClassScope(this, ScopeFlags, !AlreadyHasClassScope); 493 ParseScopeFlags ClassScopeFlags(this, ScopeFlags, AlreadyHasClassScope); 494 495 if (!AlreadyHasClassScope) 496 Actions.ActOnStartDelayedMemberDeclarations(getCurScope(), 497 Class.TagOrTemplate); 498 499 if (!Class.LateParsedDeclarations.empty()) { 500 // C++11 [expr.prim.general]p4: 501 // Otherwise, if a member-declarator declares a non-static data member 502 // (9.2) of a class X, the expression this is a prvalue of type "pointer 503 // to X" within the optional brace-or-equal-initializer. It shall not 504 // appear elsewhere in the member-declarator. 505 Sema::CXXThisScopeRAII ThisScope(Actions, Class.TagOrTemplate, 506 /*TypeQuals=*/(unsigned)0); 507 508 for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) { 509 Class.LateParsedDeclarations[i]->ParseLexedMemberInitializers(); 510 } 511 } 512 513 if (!AlreadyHasClassScope) 514 Actions.ActOnFinishDelayedMemberDeclarations(getCurScope(), 515 Class.TagOrTemplate); 516 517 Actions.ActOnFinishDelayedMemberInitializers(Class.TagOrTemplate); 518} 519 520void Parser::ParseLexedMemberInitializer(LateParsedMemberInitializer &MI) { 521 if (!MI.Field || MI.Field->isInvalidDecl()) 522 return; 523 524 // Append the current token at the end of the new token stream so that it 525 // doesn't get lost. 526 MI.Toks.push_back(Tok); 527 PP.EnterTokenStream(MI.Toks.data(), MI.Toks.size(), true, false); 528 529 // Consume the previously pushed token. 530 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true); 531 532 SourceLocation EqualLoc; 533 534 ExprResult Init = ParseCXXMemberInitializer(MI.Field, /*IsFunction=*/false, 535 EqualLoc); 536 537 Actions.ActOnCXXInClassMemberInitializer(MI.Field, EqualLoc, Init.release()); 538 539 // The next token should be our artificial terminating EOF token. 540 if (Tok.isNot(tok::eof)) { 541 SourceLocation EndLoc = PP.getLocForEndOfToken(PrevTokLocation); 542 if (!EndLoc.isValid()) 543 EndLoc = Tok.getLocation(); 544 // No fixit; we can't recover as if there were a semicolon here. 545 Diag(EndLoc, diag::err_expected_semi_decl_list); 546 547 // Consume tokens until we hit the artificial EOF. 548 while (Tok.isNot(tok::eof)) 549 ConsumeAnyToken(); 550 } 551 ConsumeAnyToken(); 552} 553 554/// ConsumeAndStoreUntil - Consume and store the token at the passed token 555/// container until the token 'T' is reached (which gets 556/// consumed/stored too, if ConsumeFinalToken). 557/// If StopAtSemi is true, then we will stop early at a ';' character. 558/// Returns true if token 'T1' or 'T2' was found. 559/// NOTE: This is a specialized version of Parser::SkipUntil. 560bool Parser::ConsumeAndStoreUntil(tok::TokenKind T1, tok::TokenKind T2, 561 CachedTokens &Toks, 562 bool StopAtSemi, bool ConsumeFinalToken) { 563 // We always want this function to consume at least one token if the first 564 // token isn't T and if not at EOF. 565 bool isFirstTokenConsumed = true; 566 while (1) { 567 // If we found one of the tokens, stop and return true. 568 if (Tok.is(T1) || Tok.is(T2)) { 569 if (ConsumeFinalToken) { 570 Toks.push_back(Tok); 571 ConsumeAnyToken(); 572 } 573 return true; 574 } 575 576 switch (Tok.getKind()) { 577 case tok::eof: 578 // Ran out of tokens. 579 return false; 580 581 case tok::l_paren: 582 // Recursively consume properly-nested parens. 583 Toks.push_back(Tok); 584 ConsumeParen(); 585 ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false); 586 break; 587 case tok::l_square: 588 // Recursively consume properly-nested square brackets. 589 Toks.push_back(Tok); 590 ConsumeBracket(); 591 ConsumeAndStoreUntil(tok::r_square, Toks, /*StopAtSemi=*/false); 592 break; 593 case tok::l_brace: 594 // Recursively consume properly-nested braces. 595 Toks.push_back(Tok); 596 ConsumeBrace(); 597 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false); 598 break; 599 600 // Okay, we found a ']' or '}' or ')', which we think should be balanced. 601 // Since the user wasn't looking for this token (if they were, it would 602 // already be handled), this isn't balanced. If there is a LHS token at a 603 // higher level, we will assume that this matches the unbalanced token 604 // and return it. Otherwise, this is a spurious RHS token, which we skip. 605 case tok::r_paren: 606 if (ParenCount && !isFirstTokenConsumed) 607 return false; // Matches something. 608 Toks.push_back(Tok); 609 ConsumeParen(); 610 break; 611 case tok::r_square: 612 if (BracketCount && !isFirstTokenConsumed) 613 return false; // Matches something. 614 Toks.push_back(Tok); 615 ConsumeBracket(); 616 break; 617 case tok::r_brace: 618 if (BraceCount && !isFirstTokenConsumed) 619 return false; // Matches something. 620 Toks.push_back(Tok); 621 ConsumeBrace(); 622 break; 623 624 case tok::code_completion: 625 Toks.push_back(Tok); 626 ConsumeCodeCompletionToken(); 627 break; 628 629 case tok::string_literal: 630 case tok::wide_string_literal: 631 case tok::utf8_string_literal: 632 case tok::utf16_string_literal: 633 case tok::utf32_string_literal: 634 Toks.push_back(Tok); 635 ConsumeStringToken(); 636 break; 637 case tok::semi: 638 if (StopAtSemi) 639 return false; 640 // FALL THROUGH. 641 default: 642 // consume this token. 643 Toks.push_back(Tok); 644 ConsumeToken(); 645 break; 646 } 647 isFirstTokenConsumed = false; 648 } 649} 650 651/// \brief Consume tokens and store them in the passed token container until 652/// we've passed the try keyword and constructor initializers and have consumed 653/// the opening brace of the function body. The opening brace will be consumed 654/// if and only if there was no error. 655/// 656/// \return True on error. 657bool Parser::ConsumeAndStoreFunctionPrologue(CachedTokens &Toks) { 658 if (Tok.is(tok::kw_try)) { 659 Toks.push_back(Tok); 660 ConsumeToken(); 661 } 662 bool ReadInitializer = false; 663 if (Tok.is(tok::colon)) { 664 // Initializers can contain braces too. 665 Toks.push_back(Tok); 666 ConsumeToken(); 667 668 while (Tok.is(tok::identifier) || Tok.is(tok::coloncolon)) { 669 if (Tok.is(tok::eof) || Tok.is(tok::semi)) 670 return Diag(Tok.getLocation(), diag::err_expected_lbrace); 671 672 // Grab the identifier. 673 if (!ConsumeAndStoreUntil(tok::l_paren, tok::l_brace, Toks, 674 /*StopAtSemi=*/true, 675 /*ConsumeFinalToken=*/false)) 676 return Diag(Tok.getLocation(), diag::err_expected_lparen); 677 678 tok::TokenKind kind = Tok.getKind(); 679 Toks.push_back(Tok); 680 bool IsLParen = (kind == tok::l_paren); 681 SourceLocation LOpen = Tok.getLocation(); 682 683 if (IsLParen) { 684 ConsumeParen(); 685 } else { 686 assert(kind == tok::l_brace && "Must be left paren or brace here."); 687 ConsumeBrace(); 688 // In C++03, this has to be the start of the function body, which 689 // means the initializer is malformed; we'll diagnose it later. 690 if (!getLangOpts().CPlusPlus11) 691 return false; 692 } 693 694 // Grab the initializer 695 if (!ConsumeAndStoreUntil(IsLParen ? tok::r_paren : tok::r_brace, 696 Toks, /*StopAtSemi=*/true)) { 697 Diag(Tok, IsLParen ? diag::err_expected_rparen : 698 diag::err_expected_rbrace); 699 Diag(LOpen, diag::note_matching) << (IsLParen ? "(" : "{"); 700 return true; 701 } 702 703 // Grab pack ellipsis, if present 704 if (Tok.is(tok::ellipsis)) { 705 Toks.push_back(Tok); 706 ConsumeToken(); 707 } 708 709 // Grab the separating comma, if any. 710 if (Tok.is(tok::comma)) { 711 Toks.push_back(Tok); 712 ConsumeToken(); 713 } else if (Tok.isNot(tok::l_brace)) { 714 ReadInitializer = true; 715 break; 716 } 717 } 718 } 719 720 // Grab any remaining garbage to be diagnosed later. We stop when we reach a 721 // brace: an opening one is the function body, while a closing one probably 722 // means we've reached the end of the class. 723 ConsumeAndStoreUntil(tok::l_brace, tok::r_brace, Toks, 724 /*StopAtSemi=*/true, 725 /*ConsumeFinalToken=*/false); 726 if (Tok.isNot(tok::l_brace)) { 727 if (ReadInitializer) 728 return Diag(Tok.getLocation(), diag::err_expected_lbrace_or_comma); 729 return Diag(Tok.getLocation(), diag::err_expected_lbrace); 730 } 731 732 Toks.push_back(Tok); 733 ConsumeBrace(); 734 return false; 735} 736