contrib/llvm/tools/clang/lib/Parse/ParseCXXInlineMethods.cpp

   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"
  20 using namespace clang;
  21
  22 /// Get the FunctionDecl for a function or function template decl.
  23 static 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.
  32 NamedDecl *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.
 200 void 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
 236 Parser::LateParsedDeclaration::~LateParsedDeclaration() {}
 237 void Parser::LateParsedDeclaration::ParseLexedMethodDeclarations() {}
 238 void Parser::LateParsedDeclaration::ParseLexedMemberInitializers() {}
 239 void Parser::LateParsedDeclaration::ParseLexedMethodDefs() {}
 240
 241 Parser::LateParsedClass::LateParsedClass(Parser *P, ParsingClass *C)
 242   : Self(P), Class(C) {}
 243
 244 Parser::LateParsedClass::~LateParsedClass() {
 245   Self->DeallocateParsedClasses(Class);
 246 }
 247
 248 void Parser::LateParsedClass::ParseLexedMethodDeclarations() {
 249   Self->ParseLexedMethodDeclarations(*Class);
 250 }
 251
 252 void Parser::LateParsedClass::ParseLexedMemberInitializers() {
 253   Self->ParseLexedMemberInitializers(*Class);
 254 }
 255
 256 void Parser::LateParsedClass::ParseLexedMethodDefs() {
 257   Self->ParseLexedMethodDefs(*Class);
 258 }
 259
 260 void Parser::LateParsedMethodDeclaration::ParseLexedMethodDeclarations() {
 261   Self->ParseLexedMethodDeclaration(*this);
 262 }
 263
 264 void Parser::LexedMethod::ParseLexedMethodDefs() {
 265   Self->ParseLexedMethodDef(*this);
 266 }
 267
 268 void 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.
 276 void 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
 301 void 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.
 388 void 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
 405 void 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.
 485 void 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
 525 void 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.
 565 bool 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.
 662 bool 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.
 832 bool 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.
 855 class Parser::UnannotatedTentativeParsingAction : public TentativeParsingAction {
 856 public:
 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
 882 private:
 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.
 892 bool 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 }