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

   1 //===--- ParseDeclCXX.cpp - C++ Declaration Parsing -----------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file implements the C++ Declaration portions of the Parser interfaces.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Basic/OperatorKinds.h"
  15 #include "clang/Parse/Parser.h"
  16 #include "clang/Parse/ParseDiagnostic.h"
  17 #include "clang/Sema/DeclSpec.h"
  18 #include "clang/Sema/Scope.h"
  19 #include "clang/Sema/ParsedTemplate.h"
  20 #include "clang/Sema/PrettyDeclStackTrace.h"
  21 #include "RAIIObjectsForParser.h"
  22 using namespace clang;
  23
  24 /// ParseNamespace - We know that the current token is a namespace keyword. This
  25 /// may either be a top level namespace or a block-level namespace alias. If
  26 /// there was an inline keyword, it has already been parsed.
  27 ///
  28 ///       namespace-definition: [C++ 7.3: basic.namespace]
  29 ///         named-namespace-definition
  30 ///         unnamed-namespace-definition
  31 ///
  32 ///       unnamed-namespace-definition:
  33 ///         'inline'[opt] 'namespace' attributes[opt] '{' namespace-body '}'
  34 ///
  35 ///       named-namespace-definition:
  36 ///         original-namespace-definition
  37 ///         extension-namespace-definition
  38 ///
  39 ///       original-namespace-definition:
  40 ///         'inline'[opt] 'namespace' identifier attributes[opt]
  41 ///             '{' namespace-body '}'
  42 ///
  43 ///       extension-namespace-definition:
  44 ///         'inline'[opt] 'namespace' original-namespace-name
  45 ///             '{' namespace-body '}'
  46 ///
  47 ///       namespace-alias-definition:  [C++ 7.3.2: namespace.alias]
  48 ///         'namespace' identifier '=' qualified-namespace-specifier ';'
  49 ///
  50 Decl *Parser::ParseNamespace(unsigned Context,
  51                              SourceLocation &DeclEnd,
  52                              SourceLocation InlineLoc) {
  53   assert(Tok.is(tok::kw_namespace) && "Not a namespace!");
  54   SourceLocation NamespaceLoc = ConsumeToken();  // eat the 'namespace'.
  55   ObjCDeclContextSwitch ObjCDC(*this);
  56
  57   if (Tok.is(tok::code_completion)) {
  58     Actions.CodeCompleteNamespaceDecl(getCurScope());
  59     cutOffParsing();
  60     return 0;
  61   }
  62
  63   SourceLocation IdentLoc;
  64   IdentifierInfo *Ident = 0;
  65   std::vector<SourceLocation> ExtraIdentLoc;
  66   std::vector<IdentifierInfo*> ExtraIdent;
  67   std::vector<SourceLocation> ExtraNamespaceLoc;
  68
  69   Token attrTok;
  70
  71   if (Tok.is(tok::identifier)) {
  72     Ident = Tok.getIdentifierInfo();
  73     IdentLoc = ConsumeToken();  // eat the identifier.
  74     while (Tok.is(tok::coloncolon) && NextToken().is(tok::identifier)) {
  75       ExtraNamespaceLoc.push_back(ConsumeToken());
  76       ExtraIdent.push_back(Tok.getIdentifierInfo());
  77       ExtraIdentLoc.push_back(ConsumeToken());
  78     }
  79   }
  80
  81   // Read label attributes, if present.
  82   ParsedAttributes attrs(AttrFactory);
  83   if (Tok.is(tok::kw___attribute)) {
  84     attrTok = Tok;
  85     ParseGNUAttributes(attrs);
  86   }
  87
  88   if (Tok.is(tok::equal)) {
  89     if (!attrs.empty())
  90       Diag(attrTok, diag::err_unexpected_namespace_attributes_alias);
  91     if (InlineLoc.isValid())
  92       Diag(InlineLoc, diag::err_inline_namespace_alias)
  93           << FixItHint::CreateRemoval(InlineLoc);
  94     return ParseNamespaceAlias(NamespaceLoc, IdentLoc, Ident, DeclEnd);
  95   }
  96
  97
  98   BalancedDelimiterTracker T(*this, tok::l_brace);
  99   if (T.consumeOpen()) {
 100     if (!ExtraIdent.empty()) {
 101       Diag(ExtraNamespaceLoc[0], diag::err_nested_namespaces_with_double_colon)
 102           << SourceRange(ExtraNamespaceLoc.front(), ExtraIdentLoc.back());
 103     }
 104     Diag(Tok, Ident ? diag::err_expected_lbrace :
 105          diag::err_expected_ident_lbrace);
 106     return 0;
 107   }
 108
 109   if (getCurScope()->isClassScope() || getCurScope()->isTemplateParamScope() ||
 110       getCurScope()->isInObjcMethodScope() || getCurScope()->getBlockParent() ||
 111       getCurScope()->getFnParent()) {
 112     if (!ExtraIdent.empty()) {
 113       Diag(ExtraNamespaceLoc[0], diag::err_nested_namespaces_with_double_colon)
 114           << SourceRange(ExtraNamespaceLoc.front(), ExtraIdentLoc.back());
 115     }
 116     Diag(T.getOpenLocation(), diag::err_namespace_nonnamespace_scope);
 117     SkipUntil(tok::r_brace, false);
 118     return 0;
 119   }
 120
 121   if (!ExtraIdent.empty()) {
 122     TentativeParsingAction TPA(*this);
 123     SkipUntil(tok::r_brace, /*StopAtSemi*/false, /*DontConsume*/true);
 124     Token rBraceToken = Tok;
 125     TPA.Revert();
 126
 127     if (!rBraceToken.is(tok::r_brace)) {
 128       Diag(ExtraNamespaceLoc[0], diag::err_nested_namespaces_with_double_colon)
 129           << SourceRange(ExtraNamespaceLoc.front(), ExtraIdentLoc.back());
 130     } else {
 131       std::string NamespaceFix;
 132       for (std::vector<IdentifierInfo*>::iterator I = ExtraIdent.begin(),
 133            E = ExtraIdent.end(); I != E; ++I) {
 134         NamespaceFix += " { namespace ";
 135         NamespaceFix += (*I)->getName();
 136       }
 137
 138       std::string RBraces;
 139       for (unsigned i = 0, e = ExtraIdent.size(); i != e; ++i)
 140         RBraces +=  "} ";
 141
 142       Diag(ExtraNamespaceLoc[0], diag::err_nested_namespaces_with_double_colon)
 143           << FixItHint::CreateReplacement(SourceRange(ExtraNamespaceLoc.front(),
 144                                                       ExtraIdentLoc.back()),
 145                                           NamespaceFix)
 146           << FixItHint::CreateInsertion(rBraceToken.getLocation(), RBraces);
 147     }
 148   }
 149
 150   // If we're still good, complain about inline namespaces in non-C++0x now.
 151   if (!getLang().CPlusPlus0x && InlineLoc.isValid())
 152     Diag(InlineLoc, diag::ext_inline_namespace);
 153
 154   // Enter a scope for the namespace.
 155   ParseScope NamespaceScope(this, Scope::DeclScope);
 156
 157   Decl *NamespcDecl =
 158     Actions.ActOnStartNamespaceDef(getCurScope(), InlineLoc, NamespaceLoc,
 159                                    IdentLoc, Ident, T.getOpenLocation(),
 160                                    attrs.getList());
 161
 162   PrettyDeclStackTraceEntry CrashInfo(Actions, NamespcDecl, NamespaceLoc,
 163                                       "parsing namespace");
 164
 165   // Parse the contents of the namespace.  This includes parsing recovery on
 166   // any improperly nested namespaces.
 167   ParseInnerNamespace(ExtraIdentLoc, ExtraIdent, ExtraNamespaceLoc, 0,
 168                       InlineLoc, attrs, T);
 169
 170   // Leave the namespace scope.
 171   NamespaceScope.Exit();
 172
 173   DeclEnd = T.getCloseLocation();
 174   Actions.ActOnFinishNamespaceDef(NamespcDecl, DeclEnd);
 175
 176   return NamespcDecl;
 177 }
 178
 179 /// ParseInnerNamespace - Parse the contents of a namespace.
 180 void Parser::ParseInnerNamespace(std::vector<SourceLocation>& IdentLoc,
 181                                  std::vector<IdentifierInfo*>& Ident,
 182                                  std::vector<SourceLocation>& NamespaceLoc,
 183                                  unsigned int index, SourceLocation& InlineLoc,
 184                                  ParsedAttributes& attrs,
 185                                  BalancedDelimiterTracker &Tracker) {
 186   if (index == Ident.size()) {
 187     while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
 188       ParsedAttributesWithRange attrs(AttrFactory);
 189       MaybeParseCXX0XAttributes(attrs);
 190       MaybeParseMicrosoftAttributes(attrs);
 191       ParseExternalDeclaration(attrs);
 192     }
 193
 194     // The caller is what called check -- we are simply calling
 195     // the close for it.
 196     Tracker.consumeClose();
 197
 198     return;
 199   }
 200
 201   // Parse improperly nested namespaces.
 202   ParseScope NamespaceScope(this, Scope::DeclScope);
 203   Decl *NamespcDecl =
 204     Actions.ActOnStartNamespaceDef(getCurScope(), SourceLocation(),
 205                                    NamespaceLoc[index], IdentLoc[index],
 206                                    Ident[index], Tracker.getOpenLocation(),
 207                                    attrs.getList());
 208
 209   ParseInnerNamespace(IdentLoc, Ident, NamespaceLoc, ++index, InlineLoc,
 210                       attrs, Tracker);
 211
 212   NamespaceScope.Exit();
 213
 214   Actions.ActOnFinishNamespaceDef(NamespcDecl, Tracker.getCloseLocation());
 215 }
 216
 217 /// ParseNamespaceAlias - Parse the part after the '=' in a namespace
 218 /// alias definition.
 219 ///
 220 Decl *Parser::ParseNamespaceAlias(SourceLocation NamespaceLoc,
 221                                   SourceLocation AliasLoc,
 222                                   IdentifierInfo *Alias,
 223                                   SourceLocation &DeclEnd) {
 224   assert(Tok.is(tok::equal) && "Not equal token");
 225
 226   ConsumeToken(); // eat the '='.
 227
 228   if (Tok.is(tok::code_completion)) {
 229     Actions.CodeCompleteNamespaceAliasDecl(getCurScope());
 230     cutOffParsing();
 231     return 0;
 232   }
 233
 234   CXXScopeSpec SS;
 235   // Parse (optional) nested-name-specifier.
 236   ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false);
 237
 238   if (SS.isInvalid() || Tok.isNot(tok::identifier)) {
 239     Diag(Tok, diag::err_expected_namespace_name);
 240     // Skip to end of the definition and eat the ';'.
 241     SkipUntil(tok::semi);
 242     return 0;
 243   }
 244
 245   // Parse identifier.
 246   IdentifierInfo *Ident = Tok.getIdentifierInfo();
 247   SourceLocation IdentLoc = ConsumeToken();
 248
 249   // Eat the ';'.
 250   DeclEnd = Tok.getLocation();
 251   ExpectAndConsume(tok::semi, diag::err_expected_semi_after_namespace_name,
 252                    "", tok::semi);
 253
 254   return Actions.ActOnNamespaceAliasDef(getCurScope(), NamespaceLoc, AliasLoc, Alias,
 255                                         SS, IdentLoc, Ident);
 256 }
 257
 258 /// ParseLinkage - We know that the current token is a string_literal
 259 /// and just before that, that extern was seen.
 260 ///
 261 ///       linkage-specification: [C++ 7.5p2: dcl.link]
 262 ///         'extern' string-literal '{' declaration-seq[opt] '}'
 263 ///         'extern' string-literal declaration
 264 ///
 265 Decl *Parser::ParseLinkage(ParsingDeclSpec &DS, unsigned Context) {
 266   assert(Tok.is(tok::string_literal) && "Not a string literal!");
 267   llvm::SmallString<8> LangBuffer;
 268   bool Invalid = false;
 269   StringRef Lang = PP.getSpelling(Tok, LangBuffer, &Invalid);
 270   if (Invalid)
 271     return 0;
 272
 273   SourceLocation Loc = ConsumeStringToken();
 274
 275   ParseScope LinkageScope(this, Scope::DeclScope);
 276   Decl *LinkageSpec
 277     = Actions.ActOnStartLinkageSpecification(getCurScope(),
 278                                              DS.getSourceRange().getBegin(),
 279                                              Loc, Lang,
 280                                       Tok.is(tok::l_brace) ? Tok.getLocation()
 281                                                            : SourceLocation());
 282
 283   ParsedAttributesWithRange attrs(AttrFactory);
 284   MaybeParseCXX0XAttributes(attrs);
 285   MaybeParseMicrosoftAttributes(attrs);
 286
 287   if (Tok.isNot(tok::l_brace)) {
 288     // Reset the source range in DS, as the leading "extern"
 289     // does not really belong to the inner declaration ...
 290     DS.SetRangeStart(SourceLocation());
 291     DS.SetRangeEnd(SourceLocation());
 292     // ... but anyway remember that such an "extern" was seen.
 293     DS.setExternInLinkageSpec(true);
 294     ParseExternalDeclaration(attrs, &DS);
 295     return Actions.ActOnFinishLinkageSpecification(getCurScope(), LinkageSpec,
 296                                                    SourceLocation());
 297   }
 298
 299   DS.abort();
 300
 301   ProhibitAttributes(attrs);
 302
 303   BalancedDelimiterTracker T(*this, tok::l_brace);
 304   T.consumeOpen();
 305   while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
 306     ParsedAttributesWithRange attrs(AttrFactory);
 307     MaybeParseCXX0XAttributes(attrs);
 308     MaybeParseMicrosoftAttributes(attrs);
 309     ParseExternalDeclaration(attrs);
 310   }
 311
 312   T.consumeClose();
 313   return Actions.ActOnFinishLinkageSpecification(getCurScope(), LinkageSpec,
 314                                                  T.getCloseLocation());
 315 }
 316
 317 /// ParseUsingDirectiveOrDeclaration - Parse C++ using using-declaration or
 318 /// using-directive. Assumes that current token is 'using'.
 319 Decl *Parser::ParseUsingDirectiveOrDeclaration(unsigned Context,
 320                                          const ParsedTemplateInfo &TemplateInfo,
 321                                                SourceLocation &DeclEnd,
 322                                              ParsedAttributesWithRange &attrs,
 323                                                Decl **OwnedType) {
 324   assert(Tok.is(tok::kw_using) && "Not using token");
 325   ObjCDeclContextSwitch ObjCDC(*this);
 326
 327   // Eat 'using'.
 328   SourceLocation UsingLoc = ConsumeToken();
 329
 330   if (Tok.is(tok::code_completion)) {
 331     Actions.CodeCompleteUsing(getCurScope());
 332     cutOffParsing();
 333     return 0;
 334   }
 335
 336   // 'using namespace' means this is a using-directive.
 337   if (Tok.is(tok::kw_namespace)) {
 338     // Template parameters are always an error here.
 339     if (TemplateInfo.Kind) {
 340       SourceRange R = TemplateInfo.getSourceRange();
 341       Diag(UsingLoc, diag::err_templated_using_directive)
 342         << R << FixItHint::CreateRemoval(R);
 343     }
 344
 345     return ParseUsingDirective(Context, UsingLoc, DeclEnd, attrs);
 346   }
 347
 348   // Otherwise, it must be a using-declaration or an alias-declaration.
 349
 350   // Using declarations can't have attributes.
 351   ProhibitAttributes(attrs);
 352
 353   return ParseUsingDeclaration(Context, TemplateInfo, UsingLoc, DeclEnd,
 354                                     AS_none, OwnedType);
 355 }
 356
 357 /// ParseUsingDirective - Parse C++ using-directive, assumes
 358 /// that current token is 'namespace' and 'using' was already parsed.
 359 ///
 360 ///       using-directive: [C++ 7.3.p4: namespace.udir]
 361 ///        'using' 'namespace' ::[opt] nested-name-specifier[opt]
 362 ///                 namespace-name ;
 363 /// [GNU] using-directive:
 364 ///        'using' 'namespace' ::[opt] nested-name-specifier[opt]
 365 ///                 namespace-name attributes[opt] ;
 366 ///
 367 Decl *Parser::ParseUsingDirective(unsigned Context,
 368                                   SourceLocation UsingLoc,
 369                                   SourceLocation &DeclEnd,
 370                                   ParsedAttributes &attrs) {
 371   assert(Tok.is(tok::kw_namespace) && "Not 'namespace' token");
 372
 373   // Eat 'namespace'.
 374   SourceLocation NamespcLoc = ConsumeToken();
 375
 376   if (Tok.is(tok::code_completion)) {
 377     Actions.CodeCompleteUsingDirective(getCurScope());
 378     cutOffParsing();
 379     return 0;
 380   }
 381
 382   CXXScopeSpec SS;
 383   // Parse (optional) nested-name-specifier.
 384   ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false);
 385
 386   IdentifierInfo *NamespcName = 0;
 387   SourceLocation IdentLoc = SourceLocation();
 388
 389   // Parse namespace-name.
 390   if (SS.isInvalid() || Tok.isNot(tok::identifier)) {
 391     Diag(Tok, diag::err_expected_namespace_name);
 392     // If there was invalid namespace name, skip to end of decl, and eat ';'.
 393     SkipUntil(tok::semi);
 394     // FIXME: Are there cases, when we would like to call ActOnUsingDirective?
 395     return 0;
 396   }
 397
 398   // Parse identifier.
 399   NamespcName = Tok.getIdentifierInfo();
 400   IdentLoc = ConsumeToken();
 401
 402   // Parse (optional) attributes (most likely GNU strong-using extension).
 403   bool GNUAttr = false;
 404   if (Tok.is(tok::kw___attribute)) {
 405     GNUAttr = true;
 406     ParseGNUAttributes(attrs);
 407   }
 408
 409   // Eat ';'.
 410   DeclEnd = Tok.getLocation();
 411   ExpectAndConsume(tok::semi,
 412                    GNUAttr ? diag::err_expected_semi_after_attribute_list
 413                            : diag::err_expected_semi_after_namespace_name,
 414                    "", tok::semi);
 415
 416   return Actions.ActOnUsingDirective(getCurScope(), UsingLoc, NamespcLoc, SS,
 417                                      IdentLoc, NamespcName, attrs.getList());
 418 }
 419
 420 /// ParseUsingDeclaration - Parse C++ using-declaration or alias-declaration.
 421 /// Assumes that 'using' was already seen.
 422 ///
 423 ///     using-declaration: [C++ 7.3.p3: namespace.udecl]
 424 ///       'using' 'typename'[opt] ::[opt] nested-name-specifier
 425 ///               unqualified-id
 426 ///       'using' :: unqualified-id
 427 ///
 428 ///     alias-declaration: C++0x [decl.typedef]p2
 429 ///       'using' identifier = type-id ;
 430 ///
 431 Decl *Parser::ParseUsingDeclaration(unsigned Context,
 432                                     const ParsedTemplateInfo &TemplateInfo,
 433                                     SourceLocation UsingLoc,
 434                                     SourceLocation &DeclEnd,
 435                                     AccessSpecifier AS,
 436                                     Decl **OwnedType) {
 437   CXXScopeSpec SS;
 438   SourceLocation TypenameLoc;
 439   bool IsTypeName;
 440
 441   // Ignore optional 'typename'.
 442   // FIXME: This is wrong; we should parse this as a typename-specifier.
 443   if (Tok.is(tok::kw_typename)) {
 444     TypenameLoc = Tok.getLocation();
 445     ConsumeToken();
 446     IsTypeName = true;
 447   }
 448   else
 449     IsTypeName = false;
 450
 451   // Parse nested-name-specifier.
 452   ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false);
 453
 454   // Check nested-name specifier.
 455   if (SS.isInvalid()) {
 456     SkipUntil(tok::semi);
 457     return 0;
 458   }
 459
 460   // Parse the unqualified-id. We allow parsing of both constructor and
 461   // destructor names and allow the action module to diagnose any semantic
 462   // errors.
 463   UnqualifiedId Name;
 464   if (ParseUnqualifiedId(SS,
 465                          /*EnteringContext=*/false,
 466                          /*AllowDestructorName=*/true,
 467                          /*AllowConstructorName=*/true,
 468                          ParsedType(),
 469                          Name)) {
 470     SkipUntil(tok::semi);
 471     return 0;
 472   }
 473
 474   ParsedAttributes attrs(AttrFactory);
 475
 476   // Maybe this is an alias-declaration.
 477   bool IsAliasDecl = Tok.is(tok::equal);
 478   TypeResult TypeAlias;
 479   if (IsAliasDecl) {
 480     // TODO: Attribute support. C++0x attributes may appear before the equals.
 481     // Where can GNU attributes appear?
 482     ConsumeToken();
 483
 484     if (!getLang().CPlusPlus0x)
 485       Diag(Tok.getLocation(), diag::ext_alias_declaration);
 486
 487     // Type alias templates cannot be specialized.
 488     int SpecKind = -1;
 489     if (TemplateInfo.Kind == ParsedTemplateInfo::Template &&
 490         Name.getKind() == UnqualifiedId::IK_TemplateId)
 491       SpecKind = 0;
 492     if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization)
 493       SpecKind = 1;
 494     if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation)
 495       SpecKind = 2;
 496     if (SpecKind != -1) {
 497       SourceRange Range;
 498       if (SpecKind == 0)
 499         Range = SourceRange(Name.TemplateId->LAngleLoc,
 500                             Name.TemplateId->RAngleLoc);
 501       else
 502         Range = TemplateInfo.getSourceRange();
 503       Diag(Range.getBegin(), diag::err_alias_declaration_specialization)
 504         << SpecKind << Range;
 505       SkipUntil(tok::semi);
 506       return 0;
 507     }
 508
 509     // Name must be an identifier.
 510     if (Name.getKind() != UnqualifiedId::IK_Identifier) {
 511       Diag(Name.StartLocation, diag::err_alias_declaration_not_identifier);
 512       // No removal fixit: can't recover from this.
 513       SkipUntil(tok::semi);
 514       return 0;
 515     } else if (IsTypeName)
 516       Diag(TypenameLoc, diag::err_alias_declaration_not_identifier)
 517         << FixItHint::CreateRemoval(SourceRange(TypenameLoc,
 518                              SS.isNotEmpty() ? SS.getEndLoc() : TypenameLoc));
 519     else if (SS.isNotEmpty())
 520       Diag(SS.getBeginLoc(), diag::err_alias_declaration_not_identifier)
 521         << FixItHint::CreateRemoval(SS.getRange());
 522
 523     TypeAlias = ParseTypeName(0, TemplateInfo.Kind ?
 524                               Declarator::AliasTemplateContext :
 525                               Declarator::AliasDeclContext, AS, OwnedType);
 526   } else
 527     // Parse (optional) attributes (most likely GNU strong-using extension).
 528     MaybeParseGNUAttributes(attrs);
 529
 530   // Eat ';'.
 531   DeclEnd = Tok.getLocation();
 532   ExpectAndConsume(tok::semi, diag::err_expected_semi_after,
 533                    !attrs.empty() ? "attributes list" :
 534                    IsAliasDecl ? "alias declaration" : "using declaration",
 535                    tok::semi);
 536
 537   // Diagnose an attempt to declare a templated using-declaration.
 538   // In C++0x, alias-declarations can be templates:
 539   //   template <...> using id = type;
 540   if (TemplateInfo.Kind && !IsAliasDecl) {
 541     SourceRange R = TemplateInfo.getSourceRange();
 542     Diag(UsingLoc, diag::err_templated_using_declaration)
 543       << R << FixItHint::CreateRemoval(R);
 544
 545     // Unfortunately, we have to bail out instead of recovering by
 546     // ignoring the parameters, just in case the nested name specifier
 547     // depends on the parameters.
 548     return 0;
 549   }
 550
 551   // "typename" keyword is allowed for identifiers only,
 552   // because it may be a type definition.
 553   if (IsTypeName && Name.getKind() != UnqualifiedId::IK_Identifier) {
 554     Diag(Name.getSourceRange().getBegin(), diag::err_typename_identifiers_only)
 555       << FixItHint::CreateRemoval(SourceRange(TypenameLoc));
 556     // Proceed parsing, but reset the IsTypeName flag.
 557     IsTypeName = false;
 558   }
 559
 560   if (IsAliasDecl) {
 561     TemplateParameterLists *TemplateParams = TemplateInfo.TemplateParams;
 562     MultiTemplateParamsArg TemplateParamsArg(Actions,
 563       TemplateParams ? TemplateParams->data() : 0,
 564       TemplateParams ? TemplateParams->size() : 0);
 565     return Actions.ActOnAliasDeclaration(getCurScope(), AS, TemplateParamsArg,
 566                                          UsingLoc, Name, TypeAlias);
 567   }
 568
 569   return Actions.ActOnUsingDeclaration(getCurScope(), AS, true, UsingLoc, SS,
 570                                        Name, attrs.getList(),
 571                                        IsTypeName, TypenameLoc);
 572 }
 573
 574 /// ParseStaticAssertDeclaration - Parse C++0x or C1X static_assert-declaration.
 575 ///
 576 /// [C++0x] static_assert-declaration:
 577 ///           static_assert ( constant-expression  ,  string-literal  ) ;
 578 ///
 579 /// [C1X]   static_assert-declaration:
 580 ///           _Static_assert ( constant-expression  ,  string-literal  ) ;
 581 ///
 582 Decl *Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd){
 583   assert((Tok.is(tok::kw_static_assert) || Tok.is(tok::kw__Static_assert)) &&
 584          "Not a static_assert declaration");
 585
 586   if (Tok.is(tok::kw__Static_assert) && !getLang().C1X)
 587     Diag(Tok, diag::ext_c1x_static_assert);
 588
 589   SourceLocation StaticAssertLoc = ConsumeToken();
 590
 591   BalancedDelimiterTracker T(*this, tok::l_paren);
 592   if (T.consumeOpen()) {
 593     Diag(Tok, diag::err_expected_lparen);
 594     return 0;
 595   }
 596
 597   ExprResult AssertExpr(ParseConstantExpression());
 598   if (AssertExpr.isInvalid()) {
 599     SkipUntil(tok::semi);
 600     return 0;
 601   }
 602
 603   if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "", tok::semi))
 604     return 0;
 605
 606   if (Tok.isNot(tok::string_literal)) {
 607     Diag(Tok, diag::err_expected_string_literal);
 608     SkipUntil(tok::semi);
 609     return 0;
 610   }
 611
 612   ExprResult AssertMessage(ParseStringLiteralExpression());
 613   if (AssertMessage.isInvalid())
 614     return 0;
 615
 616   T.consumeClose();
 617
 618   DeclEnd = Tok.getLocation();
 619   ExpectAndConsumeSemi(diag::err_expected_semi_after_static_assert);
 620
 621   return Actions.ActOnStaticAssertDeclaration(StaticAssertLoc,
 622                                               AssertExpr.take(),
 623                                               AssertMessage.take(),
 624                                               T.getCloseLocation());
 625 }
 626
 627 /// ParseDecltypeSpecifier - Parse a C++0x decltype specifier.
 628 ///
 629 /// 'decltype' ( expression )
 630 ///
 631 void Parser::ParseDecltypeSpecifier(DeclSpec &DS) {
 632   assert(Tok.is(tok::kw_decltype) && "Not a decltype specifier");
 633
 634   SourceLocation StartLoc = ConsumeToken();
 635   BalancedDelimiterTracker T(*this, tok::l_paren);
 636   if (T.expectAndConsume(diag::err_expected_lparen_after,
 637                        "decltype", tok::r_paren)) {
 638     return;
 639   }
 640
 641   // Parse the expression
 642
 643   // C++0x [dcl.type.simple]p4:
 644   //   The operand of the decltype specifier is an unevaluated operand.
 645   EnterExpressionEvaluationContext Unevaluated(Actions,
 646                                                Sema::Unevaluated);
 647   ExprResult Result = ParseExpression();
 648   if (Result.isInvalid()) {
 649     SkipUntil(tok::r_paren);
 650     return;
 651   }
 652
 653   // Match the ')'
 654   T.consumeClose();
 655   if (T.getCloseLocation().isInvalid())
 656     return;
 657
 658   const char *PrevSpec = 0;
 659   unsigned DiagID;
 660   // Check for duplicate type specifiers (e.g. "int decltype(a)").
 661   if (DS.SetTypeSpecType(DeclSpec::TST_decltype, StartLoc, PrevSpec,
 662                          DiagID, Result.release()))
 663     Diag(StartLoc, DiagID) << PrevSpec;
 664 }
 665
 666 void Parser::ParseUnderlyingTypeSpecifier(DeclSpec &DS) {
 667   assert(Tok.is(tok::kw___underlying_type) &&
 668          "Not an underlying type specifier");
 669
 670   SourceLocation StartLoc = ConsumeToken();
 671   BalancedDelimiterTracker T(*this, tok::l_paren);
 672   if (T.expectAndConsume(diag::err_expected_lparen_after,
 673                        "__underlying_type", tok::r_paren)) {
 674     return;
 675   }
 676
 677   TypeResult Result = ParseTypeName();
 678   if (Result.isInvalid()) {
 679     SkipUntil(tok::r_paren);
 680     return;
 681   }
 682
 683   // Match the ')'
 684   T.consumeClose();
 685   if (T.getCloseLocation().isInvalid())
 686     return;
 687
 688   const char *PrevSpec = 0;
 689   unsigned DiagID;
 690   if (DS.SetTypeSpecType(DeclSpec::TST_underlyingType, StartLoc, PrevSpec,
 691                          DiagID, Result.release()))
 692     Diag(StartLoc, DiagID) << PrevSpec;
 693 }
 694
 695 /// ParseClassName - Parse a C++ class-name, which names a class. Note
 696 /// that we only check that the result names a type; semantic analysis
 697 /// will need to verify that the type names a class. The result is
 698 /// either a type or NULL, depending on whether a type name was
 699 /// found.
 700 ///
 701 ///       class-name: [C++ 9.1]
 702 ///         identifier
 703 ///         simple-template-id
 704 ///
 705 Parser::TypeResult Parser::ParseClassName(SourceLocation &EndLocation,
 706                                           CXXScopeSpec &SS) {
 707   // Check whether we have a template-id that names a type.
 708   if (Tok.is(tok::annot_template_id)) {
 709     TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
 710     if (TemplateId->Kind == TNK_Type_template ||
 711         TemplateId->Kind == TNK_Dependent_template_name) {
 712       AnnotateTemplateIdTokenAsType();
 713
 714       assert(Tok.is(tok::annot_typename) && "template-id -> type failed");
 715       ParsedType Type = getTypeAnnotation(Tok);
 716       EndLocation = Tok.getAnnotationEndLoc();
 717       ConsumeToken();
 718
 719       if (Type)
 720         return Type;
 721       return true;
 722     }
 723
 724     // Fall through to produce an error below.
 725   }
 726
 727   if (Tok.isNot(tok::identifier)) {
 728     Diag(Tok, diag::err_expected_class_name);
 729     return true;
 730   }
 731
 732   IdentifierInfo *Id = Tok.getIdentifierInfo();
 733   SourceLocation IdLoc = ConsumeToken();
 734
 735   if (Tok.is(tok::less)) {
 736     // It looks the user intended to write a template-id here, but the
 737     // template-name was wrong. Try to fix that.
 738     TemplateNameKind TNK = TNK_Type_template;
 739     TemplateTy Template;
 740     if (!Actions.DiagnoseUnknownTemplateName(*Id, IdLoc, getCurScope(),
 741                                              &SS, Template, TNK)) {
 742       Diag(IdLoc, diag::err_unknown_template_name)
 743         << Id;
 744     }
 745
 746     if (!Template)
 747       return true;
 748
 749     // Form the template name
 750     UnqualifiedId TemplateName;
 751     TemplateName.setIdentifier(Id, IdLoc);
 752
 753     // Parse the full template-id, then turn it into a type.
 754     if (AnnotateTemplateIdToken(Template, TNK, SS, TemplateName,
 755                                 SourceLocation(), true))
 756       return true;
 757     if (TNK == TNK_Dependent_template_name)
 758       AnnotateTemplateIdTokenAsType();
 759
 760     // If we didn't end up with a typename token, there's nothing more we
 761     // can do.
 762     if (Tok.isNot(tok::annot_typename))
 763       return true;
 764
 765     // Retrieve the type from the annotation token, consume that token, and
 766     // return.
 767     EndLocation = Tok.getAnnotationEndLoc();
 768     ParsedType Type = getTypeAnnotation(Tok);
 769     ConsumeToken();
 770     return Type;
 771   }
 772
 773   // We have an identifier; check whether it is actually a type.
 774   ParsedType Type = Actions.getTypeName(*Id, IdLoc, getCurScope(), &SS, true,
 775                                         false, ParsedType(),
 776                                         /*NonTrivialTypeSourceInfo=*/true);
 777   if (!Type) {
 778     Diag(IdLoc, diag::err_expected_class_name);
 779     return true;
 780   }
 781
 782   // Consume the identifier.
 783   EndLocation = IdLoc;
 784
 785   // Fake up a Declarator to use with ActOnTypeName.
 786   DeclSpec DS(AttrFactory);
 787   DS.SetRangeStart(IdLoc);
 788   DS.SetRangeEnd(EndLocation);
 789   DS.getTypeSpecScope() = SS;
 790
 791   const char *PrevSpec = 0;
 792   unsigned DiagID;
 793   DS.SetTypeSpecType(TST_typename, IdLoc, PrevSpec, DiagID, Type);
 794
 795   Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
 796   return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
 797 }
 798
 799 /// ParseClassSpecifier - Parse a C++ class-specifier [C++ class] or
 800 /// elaborated-type-specifier [C++ dcl.type.elab]; we can't tell which
 801 /// until we reach the start of a definition or see a token that
 802 /// cannot start a definition. If SuppressDeclarations is true, we do know.
 803 ///
 804 ///       class-specifier: [C++ class]
 805 ///         class-head '{' member-specification[opt] '}'
 806 ///         class-head '{' member-specification[opt] '}' attributes[opt]
 807 ///       class-head:
 808 ///         class-key identifier[opt] base-clause[opt]
 809 ///         class-key nested-name-specifier identifier base-clause[opt]
 810 ///         class-key nested-name-specifier[opt] simple-template-id
 811 ///                          base-clause[opt]
 812 /// [GNU]   class-key attributes[opt] identifier[opt] base-clause[opt]
 813 /// [GNU]   class-key attributes[opt] nested-name-specifier
 814 ///                          identifier base-clause[opt]
 815 /// [GNU]   class-key attributes[opt] nested-name-specifier[opt]
 816 ///                          simple-template-id base-clause[opt]
 817 ///       class-key:
 818 ///         'class'
 819 ///         'struct'
 820 ///         'union'
 821 ///
 822 ///       elaborated-type-specifier: [C++ dcl.type.elab]
 823 ///         class-key ::[opt] nested-name-specifier[opt] identifier
 824 ///         class-key ::[opt] nested-name-specifier[opt] 'template'[opt]
 825 ///                          simple-template-id
 826 ///
 827 ///  Note that the C++ class-specifier and elaborated-type-specifier,
 828 ///  together, subsume the C99 struct-or-union-specifier:
 829 ///
 830 ///       struct-or-union-specifier: [C99 6.7.2.1]
 831 ///         struct-or-union identifier[opt] '{' struct-contents '}'
 832 ///         struct-or-union identifier
 833 /// [GNU]   struct-or-union attributes[opt] identifier[opt] '{' struct-contents
 834 ///                                                         '}' attributes[opt]
 835 /// [GNU]   struct-or-union attributes[opt] identifier
 836 ///       struct-or-union:
 837 ///         'struct'
 838 ///         'union'
 839 void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
 840                                  SourceLocation StartLoc, DeclSpec &DS,
 841                                  const ParsedTemplateInfo &TemplateInfo,
 842                                  AccessSpecifier AS, bool SuppressDeclarations){
 843   DeclSpec::TST TagType;
 844   if (TagTokKind == tok::kw_struct)
 845     TagType = DeclSpec::TST_struct;
 846   else if (TagTokKind == tok::kw_class)
 847     TagType = DeclSpec::TST_class;
 848   else {
 849     assert(TagTokKind == tok::kw_union && "Not a class specifier");
 850     TagType = DeclSpec::TST_union;
 851   }
 852
 853   if (Tok.is(tok::code_completion)) {
 854     // Code completion for a struct, class, or union name.
 855     Actions.CodeCompleteTag(getCurScope(), TagType);
 856     return cutOffParsing();
 857   }
 858
 859   // C++03 [temp.explicit] 14.7.2/8:
 860   //   The usual access checking rules do not apply to names used to specify
 861   //   explicit instantiations.
 862   //
 863   // As an extension we do not perform access checking on the names used to
 864   // specify explicit specializations either. This is important to allow
 865   // specializing traits classes for private types.
 866   bool SuppressingAccessChecks = false;
 867   if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
 868       TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization) {
 869     Actions.ActOnStartSuppressingAccessChecks();
 870     SuppressingAccessChecks = true;
 871   }
 872
 873   ParsedAttributes attrs(AttrFactory);
 874   // If attributes exist after tag, parse them.
 875   if (Tok.is(tok::kw___attribute))
 876     ParseGNUAttributes(attrs);
 877
 878   // If declspecs exist after tag, parse them.
 879   while (Tok.is(tok::kw___declspec))
 880     ParseMicrosoftDeclSpec(attrs);
 881
 882   // If C++0x attributes exist here, parse them.
 883   // FIXME: Are we consistent with the ordering of parsing of different
 884   // styles of attributes?
 885   MaybeParseCXX0XAttributes(attrs);
 886
 887   if (TagType == DeclSpec::TST_struct &&
 888       !Tok.is(tok::identifier) &&
 889       Tok.getIdentifierInfo() &&
 890       (Tok.is(tok::kw___is_arithmetic) ||
 891        Tok.is(tok::kw___is_convertible) ||
 892        Tok.is(tok::kw___is_empty) ||
 893        Tok.is(tok::kw___is_floating_point) ||
 894        Tok.is(tok::kw___is_function) ||
 895        Tok.is(tok::kw___is_fundamental) ||
 896        Tok.is(tok::kw___is_integral) ||
 897        Tok.is(tok::kw___is_member_function_pointer) ||
 898        Tok.is(tok::kw___is_member_pointer) ||
 899        Tok.is(tok::kw___is_pod) ||
 900        Tok.is(tok::kw___is_pointer) ||
 901        Tok.is(tok::kw___is_same) ||
 902        Tok.is(tok::kw___is_scalar) ||
 903        Tok.is(tok::kw___is_signed) ||
 904        Tok.is(tok::kw___is_unsigned) ||
 905        Tok.is(tok::kw___is_void))) {
 906     // GNU libstdc++ 4.2 and libc++ use certain intrinsic names as the
 907     // name of struct templates, but some are keywords in GCC >= 4.3
 908     // and Clang. Therefore, when we see the token sequence "struct
 909     // X", make X into a normal identifier rather than a keyword, to
 910     // allow libstdc++ 4.2 and libc++ to work properly.
 911     Tok.getIdentifierInfo()->RevertTokenIDToIdentifier();
 912     Tok.setKind(tok::identifier);
 913   }
 914
 915   // Parse the (optional) nested-name-specifier.
 916   CXXScopeSpec &SS = DS.getTypeSpecScope();
 917   if (getLang().CPlusPlus) {
 918     // "FOO : BAR" is not a potential typo for "FOO::BAR".
 919     ColonProtectionRAIIObject X(*this);
 920
 921     if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), true))
 922       DS.SetTypeSpecError();
 923     if (SS.isSet())
 924       if (Tok.isNot(tok::identifier) && Tok.isNot(tok::annot_template_id))
 925         Diag(Tok, diag::err_expected_ident);
 926   }
 927
 928   TemplateParameterLists *TemplateParams = TemplateInfo.TemplateParams;
 929
 930   // Parse the (optional) class name or simple-template-id.
 931   IdentifierInfo *Name = 0;
 932   SourceLocation NameLoc;
 933   TemplateIdAnnotation *TemplateId = 0;
 934   if (Tok.is(tok::identifier)) {
 935     Name = Tok.getIdentifierInfo();
 936     NameLoc = ConsumeToken();
 937
 938     if (Tok.is(tok::less) && getLang().CPlusPlus) {
 939       // The name was supposed to refer to a template, but didn't.
 940       // Eat the template argument list and try to continue parsing this as
 941       // a class (or template thereof).
 942       TemplateArgList TemplateArgs;
 943       SourceLocation LAngleLoc, RAngleLoc;
 944       if (ParseTemplateIdAfterTemplateName(TemplateTy(), NameLoc, SS,
 945                                            true, LAngleLoc,
 946                                            TemplateArgs, RAngleLoc)) {
 947         // We couldn't parse the template argument list at all, so don't
 948         // try to give any location information for the list.
 949         LAngleLoc = RAngleLoc = SourceLocation();
 950       }
 951
 952       Diag(NameLoc, diag::err_explicit_spec_non_template)
 953         << (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation)
 954         << (TagType == DeclSpec::TST_class? 0
 955             : TagType == DeclSpec::TST_struct? 1
 956             : 2)
 957         << Name
 958         << SourceRange(LAngleLoc, RAngleLoc);
 959
 960       // Strip off the last template parameter list if it was empty, since
 961       // we've removed its template argument list.
 962       if (TemplateParams && TemplateInfo.LastParameterListWasEmpty) {
 963         if (TemplateParams && TemplateParams->size() > 1) {
 964           TemplateParams->pop_back();
 965         } else {
 966           TemplateParams = 0;
 967           const_cast<ParsedTemplateInfo&>(TemplateInfo).Kind
 968             = ParsedTemplateInfo::NonTemplate;
 969         }
 970       } else if (TemplateInfo.Kind
 971                                 == ParsedTemplateInfo::ExplicitInstantiation) {
 972         // Pretend this is just a forward declaration.
 973         TemplateParams = 0;
 974         const_cast<ParsedTemplateInfo&>(TemplateInfo).Kind
 975           = ParsedTemplateInfo::NonTemplate;
 976         const_cast<ParsedTemplateInfo&>(TemplateInfo).TemplateLoc
 977           = SourceLocation();
 978         const_cast<ParsedTemplateInfo&>(TemplateInfo).ExternLoc
 979           = SourceLocation();
 980       }
 981     }
 982   } else if (Tok.is(tok::annot_template_id)) {
 983     TemplateId = takeTemplateIdAnnotation(Tok);
 984     NameLoc = ConsumeToken();
 985
 986     if (TemplateId->Kind != TNK_Type_template &&
 987         TemplateId->Kind != TNK_Dependent_template_name) {
 988       // The template-name in the simple-template-id refers to
 989       // something other than a class template. Give an appropriate
 990       // error message and skip to the ';'.
 991       SourceRange Range(NameLoc);
 992       if (SS.isNotEmpty())
 993         Range.setBegin(SS.getBeginLoc());
 994
 995       Diag(TemplateId->LAngleLoc, diag::err_template_spec_syntax_non_template)
 996         << Name << static_cast<int>(TemplateId->Kind) << Range;
 997
 998       DS.SetTypeSpecError();
 999       SkipUntil(tok::semi, false, true);
1000       if (SuppressingAccessChecks)
1001         Actions.ActOnStopSuppressingAccessChecks();
1002
1003       return;
1004     }
1005   }
1006
1007   // As soon as we're finished parsing the class's template-id, turn access
1008   // checking back on.
1009   if (SuppressingAccessChecks)
1010     Actions.ActOnStopSuppressingAccessChecks();
1011
1012   // There are four options here.  If we have 'struct foo;', then this
1013   // is either a forward declaration or a friend declaration, which
1014   // have to be treated differently.  If we have 'struct foo {...',
1015   // 'struct foo :...' or 'struct foo final[opt]' then this is a
1016   // definition. Otherwise we have something like 'struct foo xyz', a reference.
1017   // However, in some contexts, things look like declarations but are just
1018   // references, e.g.
1019   // new struct s;
1020   // or
1021   // &T::operator struct s;
1022   // For these, SuppressDeclarations is true.
1023   Sema::TagUseKind TUK;
1024   if (SuppressDeclarations)
1025     TUK = Sema::TUK_Reference;
1026   else if (Tok.is(tok::l_brace) ||
1027            (getLang().CPlusPlus && Tok.is(tok::colon)) ||
1028            isCXX0XFinalKeyword()) {
1029     if (DS.isFriendSpecified()) {
1030       // C++ [class.friend]p2:
1031       //   A class shall not be defined in a friend declaration.
1032       Diag(Tok.getLocation(), diag::err_friend_decl_defines_class)
1033         << SourceRange(DS.getFriendSpecLoc());
1034
1035       // Skip everything up to the semicolon, so that this looks like a proper
1036       // friend class (or template thereof) declaration.
1037       SkipUntil(tok::semi, true, true);
1038       TUK = Sema::TUK_Friend;
1039     } else {
1040       // Okay, this is a class definition.
1041       TUK = Sema::TUK_Definition;
1042     }
1043   } else if (Tok.is(tok::semi))
1044     TUK = DS.isFriendSpecified() ? Sema::TUK_Friend : Sema::TUK_Declaration;
1045   else
1046     TUK = Sema::TUK_Reference;
1047
1048   if (!Name && !TemplateId && (DS.getTypeSpecType() == DeclSpec::TST_error ||
1049                                TUK != Sema::TUK_Definition)) {
1050     if (DS.getTypeSpecType() != DeclSpec::TST_error) {
1051       // We have a declaration or reference to an anonymous class.
1052       Diag(StartLoc, diag::err_anon_type_definition)
1053         << DeclSpec::getSpecifierName(TagType);
1054     }
1055
1056     SkipUntil(tok::comma, true);
1057     return;
1058   }
1059
1060   // Create the tag portion of the class or class template.
1061   DeclResult TagOrTempResult = true; // invalid
1062   TypeResult TypeResult = true; // invalid
1063
1064   bool Owned = false;
1065   if (TemplateId) {
1066     // Explicit specialization, class template partial specialization,
1067     // or explicit instantiation.
1068     ASTTemplateArgsPtr TemplateArgsPtr(Actions,
1069                                        TemplateId->getTemplateArgs(),
1070                                        TemplateId->NumArgs);
1071     if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation &&
1072         TUK == Sema::TUK_Declaration) {
1073       // This is an explicit instantiation of a class template.
1074       TagOrTempResult
1075         = Actions.ActOnExplicitInstantiation(getCurScope(),
1076                                              TemplateInfo.ExternLoc,
1077                                              TemplateInfo.TemplateLoc,
1078                                              TagType,
1079                                              StartLoc,
1080                                              SS,
1081                                              TemplateId->Template,
1082                                              TemplateId->TemplateNameLoc,
1083                                              TemplateId->LAngleLoc,
1084                                              TemplateArgsPtr,
1085                                              TemplateId->RAngleLoc,
1086                                              attrs.getList());
1087
1088     // Friend template-ids are treated as references unless
1089     // they have template headers, in which case they're ill-formed
1090     // (FIXME: "template <class T> friend class A<T>::B<int>;").
1091     // We diagnose this error in ActOnClassTemplateSpecialization.
1092     } else if (TUK == Sema::TUK_Reference ||
1093                (TUK == Sema::TUK_Friend &&
1094                 TemplateInfo.Kind == ParsedTemplateInfo::NonTemplate)) {
1095       TypeResult = Actions.ActOnTagTemplateIdType(TUK, TagType,
1096                                                   StartLoc,
1097                                                   TemplateId->SS,
1098                                                   TemplateId->Template,
1099                                                   TemplateId->TemplateNameLoc,
1100                                                   TemplateId->LAngleLoc,
1101                                                   TemplateArgsPtr,
1102                                                   TemplateId->RAngleLoc);
1103     } else {
1104       // This is an explicit specialization or a class template
1105       // partial specialization.
1106       TemplateParameterLists FakedParamLists;
1107
1108       if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) {
1109         // This looks like an explicit instantiation, because we have
1110         // something like
1111         //
1112         //   template class Foo<X>
1113         //
1114         // but it actually has a definition. Most likely, this was
1115         // meant to be an explicit specialization, but the user forgot
1116         // the '<>' after 'template'.
1117         assert(TUK == Sema::TUK_Definition && "Expected a definition here");
1118
1119         SourceLocation LAngleLoc
1120           = PP.getLocForEndOfToken(TemplateInfo.TemplateLoc);
1121         Diag(TemplateId->TemplateNameLoc,
1122              diag::err_explicit_instantiation_with_definition)
1123           << SourceRange(TemplateInfo.TemplateLoc)
1124           << FixItHint::CreateInsertion(LAngleLoc, "<>");
1125
1126         // Create a fake template parameter list that contains only
1127         // "template<>", so that we treat this construct as a class
1128         // template specialization.
1129         FakedParamLists.push_back(
1130           Actions.ActOnTemplateParameterList(0, SourceLocation(),
1131                                              TemplateInfo.TemplateLoc,
1132                                              LAngleLoc,
1133                                              0, 0,
1134                                              LAngleLoc));
1135         TemplateParams = &FakedParamLists;
1136       }
1137
1138       // Build the class template specialization.
1139       TagOrTempResult
1140         = Actions.ActOnClassTemplateSpecialization(getCurScope(), TagType, TUK,
1141                        StartLoc, DS.getModulePrivateSpecLoc(), SS,
1142                        TemplateId->Template,
1143                        TemplateId->TemplateNameLoc,
1144                        TemplateId->LAngleLoc,
1145                        TemplateArgsPtr,
1146                        TemplateId->RAngleLoc,
1147                        attrs.getList(),
1148                        MultiTemplateParamsArg(Actions,
1149                                     TemplateParams? &(*TemplateParams)[0] : 0,
1150                                  TemplateParams? TemplateParams->size() : 0));
1151     }
1152   } else if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation &&
1153              TUK == Sema::TUK_Declaration) {
1154     // Explicit instantiation of a member of a class template
1155     // specialization, e.g.,
1156     //
1157     //   template struct Outer<int>::Inner;
1158     //
1159     TagOrTempResult
1160       = Actions.ActOnExplicitInstantiation(getCurScope(),
1161                                            TemplateInfo.ExternLoc,
1162                                            TemplateInfo.TemplateLoc,
1163                                            TagType, StartLoc, SS, Name,
1164                                            NameLoc, attrs.getList());
1165   } else if (TUK == Sema::TUK_Friend &&
1166              TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate) {
1167     TagOrTempResult =
1168       Actions.ActOnTemplatedFriendTag(getCurScope(), DS.getFriendSpecLoc(),
1169                                       TagType, StartLoc, SS,
1170                                       Name, NameLoc, attrs.getList(),
1171                                       MultiTemplateParamsArg(Actions,
1172                                     TemplateParams? &(*TemplateParams)[0] : 0,
1173                                  TemplateParams? TemplateParams->size() : 0));
1174   } else {
1175     if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation &&
1176         TUK == Sema::TUK_Definition) {
1177       // FIXME: Diagnose this particular error.
1178     }
1179
1180     bool IsDependent = false;
1181
1182     // Don't pass down template parameter lists if this is just a tag
1183     // reference.  For example, we don't need the template parameters here:
1184     //   template <class T> class A *makeA(T t);
1185     MultiTemplateParamsArg TParams;
1186     if (TUK != Sema::TUK_Reference && TemplateParams)
1187       TParams =
1188         MultiTemplateParamsArg(&(*TemplateParams)[0], TemplateParams->size());
1189
1190     // Declaration or definition of a class type
1191     TagOrTempResult = Actions.ActOnTag(getCurScope(), TagType, TUK, StartLoc,
1192                                        SS, Name, NameLoc, attrs.getList(), AS,
1193                                        DS.getModulePrivateSpecLoc(),
1194                                        TParams, Owned, IsDependent, false,
1195                                        false, clang::TypeResult());
1196
1197     // If ActOnTag said the type was dependent, try again with the
1198     // less common call.
1199     if (IsDependent) {
1200       assert(TUK == Sema::TUK_Reference || TUK == Sema::TUK_Friend);
1201       TypeResult = Actions.ActOnDependentTag(getCurScope(), TagType, TUK,
1202                                              SS, Name, StartLoc, NameLoc);
1203     }
1204   }
1205
1206   // If there is a body, parse it and inform the actions module.
1207   if (TUK == Sema::TUK_Definition) {
1208     assert(Tok.is(tok::l_brace) ||
1209            (getLang().CPlusPlus && Tok.is(tok::colon)) ||
1210            isCXX0XFinalKeyword());
1211     if (getLang().CPlusPlus)
1212       ParseCXXMemberSpecification(StartLoc, TagType, TagOrTempResult.get());
1213     else
1214       ParseStructUnionBody(StartLoc, TagType, TagOrTempResult.get());
1215   }
1216
1217   const char *PrevSpec = 0;
1218   unsigned DiagID;
1219   bool Result;
1220   if (!TypeResult.isInvalid()) {
1221     Result = DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc,
1222                                 NameLoc.isValid() ? NameLoc : StartLoc,
1223                                 PrevSpec, DiagID, TypeResult.get());
1224   } else if (!TagOrTempResult.isInvalid()) {
1225     Result = DS.SetTypeSpecType(TagType, StartLoc,
1226                                 NameLoc.isValid() ? NameLoc : StartLoc,
1227                                 PrevSpec, DiagID, TagOrTempResult.get(), Owned);
1228   } else {
1229     DS.SetTypeSpecError();
1230     return;
1231   }
1232
1233   if (Result)
1234     Diag(StartLoc, DiagID) << PrevSpec;
1235
1236   // At this point, we've successfully parsed a class-specifier in 'definition'
1237   // form (e.g. "struct foo { int x; }".  While we could just return here, we're
1238   // going to look at what comes after it to improve error recovery.  If an
1239   // impossible token occurs next, we assume that the programmer forgot a ; at
1240   // the end of the declaration and recover that way.
1241   //
1242   // This switch enumerates the valid "follow" set for definition.
1243   if (TUK == Sema::TUK_Definition) {
1244     bool ExpectedSemi = true;
1245     switch (Tok.getKind()) {
1246     default: break;
1247     case tok::semi:               // struct foo {...} ;
1248     case tok::star:               // struct foo {...} *         P;
1249     case tok::amp:                // struct foo {...} &         R = ...
1250     case tok::identifier:         // struct foo {...} V         ;
1251     case tok::r_paren:            //(struct foo {...} )         {4}
1252     case tok::annot_cxxscope:     // struct foo {...} a::       b;
1253     case tok::annot_typename:     // struct foo {...} a         ::b;
1254     case tok::annot_template_id:  // struct foo {...} a<int>    ::b;
1255     case tok::l_paren:            // struct foo {...} (         x);
1256     case tok::comma:              // __builtin_offsetof(struct foo{...} ,
1257       ExpectedSemi = false;
1258       break;
1259     // Type qualifiers
1260     case tok::kw_const:           // struct foo {...} const     x;
1261     case tok::kw_volatile:        // struct foo {...} volatile  x;
1262     case tok::kw_restrict:        // struct foo {...} restrict  x;
1263     case tok::kw_inline:          // struct foo {...} inline    foo() {};
1264     // Storage-class specifiers
1265     case tok::kw_static:          // struct foo {...} static    x;
1266     case tok::kw_extern:          // struct foo {...} extern    x;
1267     case tok::kw_typedef:         // struct foo {...} typedef   x;
1268     case tok::kw_register:        // struct foo {...} register  x;
1269     case tok::kw_auto:            // struct foo {...} auto      x;
1270     case tok::kw_mutable:         // struct foo {...} mutable   x;
1271     case tok::kw_constexpr:       // struct foo {...} constexpr x;
1272       // As shown above, type qualifiers and storage class specifiers absolutely
1273       // can occur after class specifiers according to the grammar.  However,
1274       // almost no one actually writes code like this.  If we see one of these,
1275       // it is much more likely that someone missed a semi colon and the
1276       // type/storage class specifier we're seeing is part of the *next*
1277       // intended declaration, as in:
1278       //
1279       //   struct foo { ... }
1280       //   typedef int X;
1281       //
1282       // We'd really like to emit a missing semicolon error instead of emitting
1283       // an error on the 'int' saying that you can't have two type specifiers in
1284       // the same declaration of X.  Because of this, we look ahead past this
1285       // token to see if it's a type specifier.  If so, we know the code is
1286       // otherwise invalid, so we can produce the expected semi error.
1287       if (!isKnownToBeTypeSpecifier(NextToken()))
1288         ExpectedSemi = false;
1289       break;
1290
1291     case tok::r_brace:  // struct bar { struct foo {...} }
1292       // Missing ';' at end of struct is accepted as an extension in C mode.
1293       if (!getLang().CPlusPlus)
1294         ExpectedSemi = false;
1295       break;
1296     }
1297
1298     // C++ [temp]p3 In a template-declaration which defines a class, no
1299     // declarator is permitted.
1300     if (TemplateInfo.Kind)
1301       ExpectedSemi = true;
1302
1303     if (ExpectedSemi) {
1304       ExpectAndConsume(tok::semi, diag::err_expected_semi_after_tagdecl,
1305                        TagType == DeclSpec::TST_class ? "class"
1306                        : TagType == DeclSpec::TST_struct? "struct" : "union");
1307       // Push this token back into the preprocessor and change our current token
1308       // to ';' so that the rest of the code recovers as though there were an
1309       // ';' after the definition.
1310       PP.EnterToken(Tok);
1311       Tok.setKind(tok::semi);
1312     }
1313   }
1314 }
1315
1316 /// ParseBaseClause - Parse the base-clause of a C++ class [C++ class.derived].
1317 ///
1318 ///       base-clause : [C++ class.derived]
1319 ///         ':' base-specifier-list
1320 ///       base-specifier-list:
1321 ///         base-specifier '...'[opt]
1322 ///         base-specifier-list ',' base-specifier '...'[opt]
1323 void Parser::ParseBaseClause(Decl *ClassDecl) {
1324   assert(Tok.is(tok::colon) && "Not a base clause");
1325   ConsumeToken();
1326
1327   // Build up an array of parsed base specifiers.
1328   SmallVector<CXXBaseSpecifier *, 8> BaseInfo;
1329
1330   while (true) {
1331     // Parse a base-specifier.
1332     BaseResult Result = ParseBaseSpecifier(ClassDecl);
1333     if (Result.isInvalid()) {
1334       // Skip the rest of this base specifier, up until the comma or
1335       // opening brace.
1336       SkipUntil(tok::comma, tok::l_brace, true, true);
1337     } else {
1338       // Add this to our array of base specifiers.
1339       BaseInfo.push_back(Result.get());
1340     }
1341
1342     // If the next token is a comma, consume it and keep reading
1343     // base-specifiers.
1344     if (Tok.isNot(tok::comma)) break;
1345
1346     // Consume the comma.
1347     ConsumeToken();
1348   }
1349
1350   // Attach the base specifiers
1351   Actions.ActOnBaseSpecifiers(ClassDecl, BaseInfo.data(), BaseInfo.size());
1352 }
1353
1354 /// ParseBaseSpecifier - Parse a C++ base-specifier. A base-specifier is
1355 /// one entry in the base class list of a class specifier, for example:
1356 ///    class foo : public bar, virtual private baz {
1357 /// 'public bar' and 'virtual private baz' are each base-specifiers.
1358 ///
1359 ///       base-specifier: [C++ class.derived]
1360 ///         ::[opt] nested-name-specifier[opt] class-name
1361 ///         'virtual' access-specifier[opt] ::[opt] nested-name-specifier[opt]
1362 ///                        class-name
1363 ///         access-specifier 'virtual'[opt] ::[opt] nested-name-specifier[opt]
1364 ///                        class-name
1365 Parser::BaseResult Parser::ParseBaseSpecifier(Decl *ClassDecl) {
1366   bool IsVirtual = false;
1367   SourceLocation StartLoc = Tok.getLocation();
1368
1369   // Parse the 'virtual' keyword.
1370   if (Tok.is(tok::kw_virtual))  {
1371     ConsumeToken();
1372     IsVirtual = true;
1373   }
1374
1375   // Parse an (optional) access specifier.
1376   AccessSpecifier Access = getAccessSpecifierIfPresent();
1377   if (Access != AS_none)
1378     ConsumeToken();
1379
1380   // Parse the 'virtual' keyword (again!), in case it came after the
1381   // access specifier.
1382   if (Tok.is(tok::kw_virtual))  {
1383     SourceLocation VirtualLoc = ConsumeToken();
1384     if (IsVirtual) {
1385       // Complain about duplicate 'virtual'
1386       Diag(VirtualLoc, diag::err_dup_virtual)
1387         << FixItHint::CreateRemoval(VirtualLoc);
1388     }
1389
1390     IsVirtual = true;
1391   }
1392
1393   // Parse optional '::' and optional nested-name-specifier.
1394   CXXScopeSpec SS;
1395   ParseOptionalCXXScopeSpecifier(SS, ParsedType(), /*EnteringContext=*/false);
1396
1397   // The location of the base class itself.
1398   SourceLocation BaseLoc = Tok.getLocation();
1399
1400   // Parse the class-name.
1401   SourceLocation EndLocation;
1402   TypeResult BaseType = ParseClassName(EndLocation, SS);
1403   if (BaseType.isInvalid())
1404     return true;
1405
1406   // Parse the optional ellipsis (for a pack expansion). The ellipsis is
1407   // actually part of the base-specifier-list grammar productions, but we
1408   // parse it here for convenience.
1409   SourceLocation EllipsisLoc;
1410   if (Tok.is(tok::ellipsis))
1411     EllipsisLoc = ConsumeToken();
1412
1413   // Find the complete source range for the base-specifier.
1414   SourceRange Range(StartLoc, EndLocation);
1415
1416   // Notify semantic analysis that we have parsed a complete
1417   // base-specifier.
1418   return Actions.ActOnBaseSpecifier(ClassDecl, Range, IsVirtual, Access,
1419                                     BaseType.get(), BaseLoc, EllipsisLoc);
1420 }
1421
1422 /// getAccessSpecifierIfPresent - Determine whether the next token is
1423 /// a C++ access-specifier.
1424 ///
1425 ///       access-specifier: [C++ class.derived]
1426 ///         'private'
1427 ///         'protected'
1428 ///         'public'
1429 AccessSpecifier Parser::getAccessSpecifierIfPresent() const {
1430   switch (Tok.getKind()) {
1431   default: return AS_none;
1432   case tok::kw_private: return AS_private;
1433   case tok::kw_protected: return AS_protected;
1434   case tok::kw_public: return AS_public;
1435   }
1436 }
1437
1438 void Parser::HandleMemberFunctionDefaultArgs(Declarator& DeclaratorInfo,
1439                                              Decl *ThisDecl) {
1440   // We just declared a member function. If this member function
1441   // has any default arguments, we'll need to parse them later.
1442   LateParsedMethodDeclaration *LateMethod = 0;
1443   DeclaratorChunk::FunctionTypeInfo &FTI
1444     = DeclaratorInfo.getFunctionTypeInfo();
1445   for (unsigned ParamIdx = 0; ParamIdx < FTI.NumArgs; ++ParamIdx) {
1446     if (LateMethod || FTI.ArgInfo[ParamIdx].DefaultArgTokens) {
1447       if (!LateMethod) {
1448         // Push this method onto the stack of late-parsed method
1449         // declarations.
1450         LateMethod = new LateParsedMethodDeclaration(this, ThisDecl);
1451         getCurrentClass().LateParsedDeclarations.push_back(LateMethod);
1452         LateMethod->TemplateScope = getCurScope()->isTemplateParamScope();
1453
1454         // Add all of the parameters prior to this one (they don't
1455         // have default arguments).
1456         LateMethod->DefaultArgs.reserve(FTI.NumArgs);
1457         for (unsigned I = 0; I < ParamIdx; ++I)
1458           LateMethod->DefaultArgs.push_back(
1459                              LateParsedDefaultArgument(FTI.ArgInfo[I].Param));
1460       }
1461
1462       // Add this parameter to the list of parameters (it or may
1463       // not have a default argument).
1464       LateMethod->DefaultArgs.push_back(
1465         LateParsedDefaultArgument(FTI.ArgInfo[ParamIdx].Param,
1466                                   FTI.ArgInfo[ParamIdx].DefaultArgTokens));
1467     }
1468   }
1469 }
1470
1471 /// isCXX0XVirtSpecifier - Determine whether the next token is a C++0x
1472 /// virt-specifier.
1473 ///
1474 ///       virt-specifier:
1475 ///         override
1476 ///         final
1477 VirtSpecifiers::Specifier Parser::isCXX0XVirtSpecifier() const {
1478   if (!getLang().CPlusPlus)
1479     return VirtSpecifiers::VS_None;
1480
1481   if (Tok.is(tok::identifier)) {
1482     IdentifierInfo *II = Tok.getIdentifierInfo();
1483
1484     // Initialize the contextual keywords.
1485     if (!Ident_final) {
1486       Ident_final = &PP.getIdentifierTable().get("final");
1487       Ident_override = &PP.getIdentifierTable().get("override");
1488     }
1489
1490     if (II == Ident_override)
1491       return VirtSpecifiers::VS_Override;
1492
1493     if (II == Ident_final)
1494       return VirtSpecifiers::VS_Final;
1495   }
1496
1497   return VirtSpecifiers::VS_None;
1498 }
1499
1500 /// ParseOptionalCXX0XVirtSpecifierSeq - Parse a virt-specifier-seq.
1501 ///
1502 ///       virt-specifier-seq:
1503 ///         virt-specifier
1504 ///         virt-specifier-seq virt-specifier
1505 void Parser::ParseOptionalCXX0XVirtSpecifierSeq(VirtSpecifiers &VS) {
1506   while (true) {
1507     VirtSpecifiers::Specifier Specifier = isCXX0XVirtSpecifier();
1508     if (Specifier == VirtSpecifiers::VS_None)
1509       return;
1510
1511     // C++ [class.mem]p8:
1512     //   A virt-specifier-seq shall contain at most one of each virt-specifier.
1513     const char *PrevSpec = 0;
1514     if (VS.SetSpecifier(Specifier, Tok.getLocation(), PrevSpec))
1515       Diag(Tok.getLocation(), diag::err_duplicate_virt_specifier)
1516         << PrevSpec
1517         << FixItHint::CreateRemoval(Tok.getLocation());
1518
1519     if (!getLang().CPlusPlus0x)
1520       Diag(Tok.getLocation(), diag::ext_override_control_keyword)
1521         << VirtSpecifiers::getSpecifierName(Specifier);
1522     ConsumeToken();
1523   }
1524 }
1525
1526 /// isCXX0XFinalKeyword - Determine whether the next token is a C++0x
1527 /// contextual 'final' keyword.
1528 bool Parser::isCXX0XFinalKeyword() const {
1529   if (!getLang().CPlusPlus)
1530     return false;
1531
1532   if (!Tok.is(tok::identifier))
1533     return false;
1534
1535   // Initialize the contextual keywords.
1536   if (!Ident_final) {
1537     Ident_final = &PP.getIdentifierTable().get("final");
1538     Ident_override = &PP.getIdentifierTable().get("override");
1539   }
1540
1541   return Tok.getIdentifierInfo() == Ident_final;
1542 }
1543
1544 /// ParseCXXClassMemberDeclaration - Parse a C++ class member declaration.
1545 ///
1546 ///       member-declaration:
1547 ///         decl-specifier-seq[opt] member-declarator-list[opt] ';'
1548 ///         function-definition ';'[opt]
1549 ///         ::[opt] nested-name-specifier template[opt] unqualified-id ';'[TODO]
1550 ///         using-declaration                                            [TODO]
1551 /// [C++0x] static_assert-declaration
1552 ///         template-declaration
1553 /// [GNU]   '__extension__' member-declaration
1554 ///
1555 ///       member-declarator-list:
1556 ///         member-declarator
1557 ///         member-declarator-list ',' member-declarator
1558 ///
1559 ///       member-declarator:
1560 ///         declarator virt-specifier-seq[opt] pure-specifier[opt]
1561 ///         declarator constant-initializer[opt]
1562 /// [C++11] declarator brace-or-equal-initializer[opt]
1563 ///         identifier[opt] ':' constant-expression
1564 ///
1565 ///       virt-specifier-seq:
1566 ///         virt-specifier
1567 ///         virt-specifier-seq virt-specifier
1568 ///
1569 ///       virt-specifier:
1570 ///         override
1571 ///         final
1572 ///
1573 ///       pure-specifier:
1574 ///         '= 0'
1575 ///
1576 ///       constant-initializer:
1577 ///         '=' constant-expression
1578 ///
1579 void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS,
1580                                             AttributeList *AccessAttrs,
1581                                        const ParsedTemplateInfo &TemplateInfo,
1582                                        ParsingDeclRAIIObject *TemplateDiags) {
1583   if (Tok.is(tok::at)) {
1584     if (getLang().ObjC1 && NextToken().isObjCAtKeyword(tok::objc_defs))
1585       Diag(Tok, diag::err_at_defs_cxx);
1586     else
1587       Diag(Tok, diag::err_at_in_class);
1588
1589     ConsumeToken();
1590     SkipUntil(tok::r_brace);
1591     return;
1592   }
1593
1594   // Access declarations.
1595   if (!TemplateInfo.Kind &&
1596       (Tok.is(tok::identifier) || Tok.is(tok::coloncolon)) &&
1597       !TryAnnotateCXXScopeToken() &&
1598       Tok.is(tok::annot_cxxscope)) {
1599     bool isAccessDecl = false;
1600     if (NextToken().is(tok::identifier))
1601       isAccessDecl = GetLookAheadToken(2).is(tok::semi);
1602     else
1603       isAccessDecl = NextToken().is(tok::kw_operator);
1604
1605     if (isAccessDecl) {
1606       // Collect the scope specifier token we annotated earlier.
1607       CXXScopeSpec SS;
1608       ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false);
1609
1610       // Try to parse an unqualified-id.
1611       UnqualifiedId Name;
1612       if (ParseUnqualifiedId(SS, false, true, true, ParsedType(), Name)) {
1613         SkipUntil(tok::semi);
1614         return;
1615       }
1616
1617       // TODO: recover from mistakenly-qualified operator declarations.
1618       if (ExpectAndConsume(tok::semi,
1619                            diag::err_expected_semi_after,
1620                            "access declaration",
1621                            tok::semi))
1622         return;
1623
1624       Actions.ActOnUsingDeclaration(getCurScope(), AS,
1625                                     false, SourceLocation(),
1626                                     SS, Name,
1627                                     /* AttrList */ 0,
1628                                     /* IsTypeName */ false,
1629                                     SourceLocation());
1630       return;
1631     }
1632   }
1633
1634   // static_assert-declaration
1635   if (Tok.is(tok::kw_static_assert) || Tok.is(tok::kw__Static_assert)) {
1636     // FIXME: Check for templates
1637     SourceLocation DeclEnd;
1638     ParseStaticAssertDeclaration(DeclEnd);
1639     return;
1640   }
1641
1642   if (Tok.is(tok::kw_template)) {
1643     assert(!TemplateInfo.TemplateParams &&
1644            "Nested template improperly parsed?");
1645     SourceLocation DeclEnd;
1646     ParseDeclarationStartingWithTemplate(Declarator::MemberContext, DeclEnd,
1647                                          AS, AccessAttrs);
1648     return;
1649   }
1650
1651   // Handle:  member-declaration ::= '__extension__' member-declaration
1652   if (Tok.is(tok::kw___extension__)) {
1653     // __extension__ silences extension warnings in the subexpression.
1654     ExtensionRAIIObject O(Diags);  // Use RAII to do this.
1655     ConsumeToken();
1656     return ParseCXXClassMemberDeclaration(AS, AccessAttrs,
1657                                           TemplateInfo, TemplateDiags);
1658   }
1659
1660   // Don't parse FOO:BAR as if it were a typo for FOO::BAR, in this context it
1661   // is a bitfield.
1662   ColonProtectionRAIIObject X(*this);
1663
1664   ParsedAttributesWithRange attrs(AttrFactory);
1665   // Optional C++0x attribute-specifier
1666   MaybeParseCXX0XAttributes(attrs);
1667   MaybeParseMicrosoftAttributes(attrs);
1668
1669   if (Tok.is(tok::kw_using)) {
1670     ProhibitAttributes(attrs);
1671
1672     // Eat 'using'.
1673     SourceLocation UsingLoc = ConsumeToken();
1674
1675     if (Tok.is(tok::kw_namespace)) {
1676       Diag(UsingLoc, diag::err_using_namespace_in_class);
1677       SkipUntil(tok::semi, true, true);
1678     } else {
1679       SourceLocation DeclEnd;
1680       // Otherwise, it must be a using-declaration or an alias-declaration.
1681       ParseUsingDeclaration(Declarator::MemberContext, TemplateInfo,
1682                             UsingLoc, DeclEnd, AS);
1683     }
1684     return;
1685   }
1686
1687   // decl-specifier-seq:
1688   // Parse the common declaration-specifiers piece.
1689   ParsingDeclSpec DS(*this, TemplateDiags);
1690   DS.takeAttributesFrom(attrs);
1691   ParseDeclarationSpecifiers(DS, TemplateInfo, AS, DSC_class);
1692
1693   MultiTemplateParamsArg TemplateParams(Actions,
1694       TemplateInfo.TemplateParams? TemplateInfo.TemplateParams->data() : 0,
1695       TemplateInfo.TemplateParams? TemplateInfo.TemplateParams->size() : 0);
1696
1697   if (Tok.is(tok::semi)) {
1698     ConsumeToken();
1699     Decl *TheDecl =
1700       Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS, DS, TemplateParams);
1701     DS.complete(TheDecl);
1702     return;
1703   }
1704
1705   ParsingDeclarator DeclaratorInfo(*this, DS, Declarator::MemberContext);
1706   VirtSpecifiers VS;
1707
1708   // Hold late-parsed attributes so we can attach a Decl to them later.
1709   LateParsedAttrList LateParsedAttrs;
1710
1711   if (Tok.isNot(tok::colon)) {
1712     // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
1713     ColonProtectionRAIIObject X(*this);
1714
1715     // Parse the first declarator.
1716     ParseDeclarator(DeclaratorInfo);
1717     // Error parsing the declarator?
1718     if (!DeclaratorInfo.hasName()) {
1719       // If so, skip until the semi-colon or a }.
1720       SkipUntil(tok::r_brace, true, true);
1721       if (Tok.is(tok::semi))
1722         ConsumeToken();
1723       return;
1724     }
1725
1726     ParseOptionalCXX0XVirtSpecifierSeq(VS);
1727
1728     // If attributes exist after the declarator, but before an '{', parse them.
1729     MaybeParseGNUAttributes(DeclaratorInfo, &LateParsedAttrs);
1730
1731     // MSVC permits pure specifier on inline functions declared at class scope.
1732     // Hence check for =0 before checking for function definition.
1733     ExprResult Init;
1734     if (getLang().MicrosoftExt && Tok.is(tok::equal) &&
1735         DeclaratorInfo.isFunctionDeclarator() &&
1736         NextToken().is(tok::numeric_constant)) {
1737       ConsumeToken();
1738       Init = ParseInitializer();
1739       if (Init.isInvalid())
1740         SkipUntil(tok::comma, true, true);
1741     }
1742
1743     bool IsDefinition = false;
1744     // function-definition:
1745     //
1746     // In C++11, a non-function declarator followed by an open brace is a
1747     // braced-init-list for an in-class member initialization, not an
1748     // erroneous function definition.
1749     if (Tok.is(tok::l_brace) && !getLang().CPlusPlus0x) {
1750       IsDefinition = true;
1751     } else if (DeclaratorInfo.isFunctionDeclarator()) {
1752       if (Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try)) {
1753         IsDefinition = true;
1754       } else if (Tok.is(tok::equal)) {
1755         const Token &KW = NextToken();
1756         if (KW.is(tok::kw_default) || KW.is(tok::kw_delete))
1757           IsDefinition = true;
1758       }
1759     }
1760
1761     if (IsDefinition) {
1762       if (!DeclaratorInfo.isFunctionDeclarator()) {
1763         Diag(Tok, diag::err_func_def_no_params);
1764         ConsumeBrace();
1765         SkipUntil(tok::r_brace, true);
1766
1767         // Consume the optional ';'
1768         if (Tok.is(tok::semi))
1769           ConsumeToken();
1770         return;
1771       }
1772
1773       if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
1774         Diag(Tok, diag::err_function_declared_typedef);
1775         // This recovery skips the entire function body. It would be nice
1776         // to simply call ParseCXXInlineMethodDef() below, however Sema
1777         // assumes the declarator represents a function, not a typedef.
1778         ConsumeBrace();
1779         SkipUntil(tok::r_brace, true);
1780
1781         // Consume the optional ';'
1782         if (Tok.is(tok::semi))
1783           ConsumeToken();
1784         return;
1785       }
1786
1787       Decl *FunDecl =
1788         ParseCXXInlineMethodDef(AS, AccessAttrs, DeclaratorInfo, TemplateInfo,
1789                                 VS, Init);
1790
1791       for (unsigned i = 0, ni = LateParsedAttrs.size(); i < ni; ++i) {
1792         LateParsedAttrs[i]->setDecl(FunDecl);
1793       }
1794       LateParsedAttrs.clear();
1795
1796       // Consume the ';' - it's optional unless we have a delete or default
1797       if (Tok.is(tok::semi)) {
1798         ConsumeToken();
1799       }
1800
1801       return;
1802     }
1803   }
1804
1805   // member-declarator-list:
1806   //   member-declarator
1807   //   member-declarator-list ',' member-declarator
1808
1809   SmallVector<Decl *, 8> DeclsInGroup;
1810   ExprResult BitfieldSize;
1811
1812   while (1) {
1813     // member-declarator:
1814     //   declarator pure-specifier[opt]
1815     //   declarator brace-or-equal-initializer[opt]
1816     //   identifier[opt] ':' constant-expression
1817     if (Tok.is(tok::colon)) {
1818       ConsumeToken();
1819       BitfieldSize = ParseConstantExpression();
1820       if (BitfieldSize.isInvalid())
1821         SkipUntil(tok::comma, true, true);
1822     }
1823
1824     // If a simple-asm-expr is present, parse it.
1825     if (Tok.is(tok::kw_asm)) {
1826       SourceLocation Loc;
1827       ExprResult AsmLabel(ParseSimpleAsm(&Loc));
1828       if (AsmLabel.isInvalid())
1829         SkipUntil(tok::comma, true, true);
1830
1831       DeclaratorInfo.setAsmLabel(AsmLabel.release());
1832       DeclaratorInfo.SetRangeEnd(Loc);
1833     }
1834
1835     // If attributes exist after the declarator, parse them.
1836     MaybeParseGNUAttributes(DeclaratorInfo, &LateParsedAttrs);
1837
1838     // FIXME: When g++ adds support for this, we'll need to check whether it
1839     // goes before or after the GNU attributes and __asm__.
1840     ParseOptionalCXX0XVirtSpecifierSeq(VS);
1841
1842     bool HasInitializer = false;
1843     bool HasDeferredInitializer = false;
1844     if (Tok.is(tok::equal) || Tok.is(tok::l_brace)) {
1845       if (BitfieldSize.get()) {
1846         Diag(Tok, diag::err_bitfield_member_init);
1847         SkipUntil(tok::comma, true, true);
1848       } else {
1849         HasInitializer = true;
1850         HasDeferredInitializer = !DeclaratorInfo.isDeclarationOfFunction() &&
1851           DeclaratorInfo.getDeclSpec().getStorageClassSpec()
1852             != DeclSpec::SCS_static &&
1853           DeclaratorInfo.getDeclSpec().getStorageClassSpec()
1854             != DeclSpec::SCS_typedef;
1855       }
1856     }
1857
1858     // NOTE: If Sema is the Action module and declarator is an instance field,
1859     // this call will *not* return the created decl; It will return null.
1860     // See Sema::ActOnCXXMemberDeclarator for details.
1861
1862     Decl *ThisDecl = 0;
1863     if (DS.isFriendSpecified()) {
1864       // TODO: handle initializers, bitfields, 'delete'
1865       ThisDecl = Actions.ActOnFriendFunctionDecl(getCurScope(), DeclaratorInfo,
1866                                                  move(TemplateParams));
1867     } else {
1868       ThisDecl = Actions.ActOnCXXMemberDeclarator(getCurScope(), AS,
1869                                                   DeclaratorInfo,
1870                                                   move(TemplateParams),
1871                                                   BitfieldSize.release(),
1872                                                   VS, HasDeferredInitializer);
1873       if (AccessAttrs)
1874         Actions.ProcessDeclAttributeList(getCurScope(), ThisDecl, AccessAttrs,
1875                                          false, true);
1876     }
1877
1878     // Set the Decl for any late parsed attributes
1879     for (unsigned i = 0, ni = LateParsedAttrs.size(); i < ni; ++i) {
1880       LateParsedAttrs[i]->setDecl(ThisDecl);
1881     }
1882     LateParsedAttrs.clear();
1883
1884     // Handle the initializer.
1885     if (HasDeferredInitializer) {
1886       // The initializer was deferred; parse it and cache the tokens.
1887       if (!getLang().CPlusPlus0x)
1888         Diag(Tok, diag::warn_nonstatic_member_init_accepted_as_extension);
1889
1890       if (DeclaratorInfo.isArrayOfUnknownBound()) {
1891         // C++0x [dcl.array]p3: An array bound may also be omitted when the
1892         // declarator is followed by an initializer.
1893         //
1894         // A brace-or-equal-initializer for a member-declarator is not an
1895         // initializer in the gramamr, so this is ill-formed.
1896         Diag(Tok, diag::err_incomplete_array_member_init);
1897         SkipUntil(tok::comma, true, true);
1898         // Avoid later warnings about a class member of incomplete type.
1899         ThisDecl->setInvalidDecl();
1900       } else
1901         ParseCXXNonStaticMemberInitializer(ThisDecl);
1902     } else if (HasInitializer) {
1903       // Normal initializer.
1904       SourceLocation EqualLoc;
1905       ExprResult Init
1906         = ParseCXXMemberInitializer(DeclaratorInfo.isDeclarationOfFunction(),
1907                                     EqualLoc);
1908       if (Init.isInvalid())
1909         SkipUntil(tok::comma, true, true);
1910       else if (ThisDecl)
1911         Actions.AddInitializerToDecl(ThisDecl, Init.get(), false,
1912                                    DS.getTypeSpecType() == DeclSpec::TST_auto);
1913     } else if (ThisDecl && DS.getStorageClassSpec() == DeclSpec::SCS_static) {
1914       // No initializer.
1915       Actions.ActOnUninitializedDecl(ThisDecl,
1916                                    DS.getTypeSpecType() == DeclSpec::TST_auto);
1917     }
1918
1919     if (ThisDecl) {
1920       Actions.FinalizeDeclaration(ThisDecl);
1921       DeclsInGroup.push_back(ThisDecl);
1922     }
1923
1924     if (DeclaratorInfo.isFunctionDeclarator() &&
1925         DeclaratorInfo.getDeclSpec().getStorageClassSpec()
1926           != DeclSpec::SCS_typedef) {
1927       HandleMemberFunctionDefaultArgs(DeclaratorInfo, ThisDecl);
1928     }
1929
1930     DeclaratorInfo.complete(ThisDecl);
1931
1932     // If we don't have a comma, it is either the end of the list (a ';')
1933     // or an error, bail out.
1934     if (Tok.isNot(tok::comma))
1935       break;
1936
1937     // Consume the comma.
1938     ConsumeToken();
1939
1940     // Parse the next declarator.
1941     DeclaratorInfo.clear();
1942     VS.clear();
1943     BitfieldSize = true;
1944
1945     // Attributes are only allowed on the second declarator.
1946     MaybeParseGNUAttributes(DeclaratorInfo);
1947
1948     if (Tok.isNot(tok::colon))
1949       ParseDeclarator(DeclaratorInfo);
1950   }
1951
1952   if (ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list)) {
1953     // Skip to end of block or statement.
1954     SkipUntil(tok::r_brace, true, true);
1955     // If we stopped at a ';', eat it.
1956     if (Tok.is(tok::semi)) ConsumeToken();
1957     return;
1958   }
1959
1960   Actions.FinalizeDeclaratorGroup(getCurScope(), DS, DeclsInGroup.data(),
1961                                   DeclsInGroup.size());
1962 }
1963
1964 /// ParseCXXMemberInitializer - Parse the brace-or-equal-initializer or
1965 /// pure-specifier. Also detect and reject any attempted defaulted/deleted
1966 /// function definition. The location of the '=', if any, will be placed in
1967 /// EqualLoc.
1968 ///
1969 ///   pure-specifier:
1970 ///     '= 0'
1971 ///
1972 ///   brace-or-equal-initializer:
1973 ///     '=' initializer-expression
1974 ///     braced-init-list                       [TODO]
1975 ///
1976 ///   initializer-clause:
1977 ///     assignment-expression
1978 ///     braced-init-list                       [TODO]
1979 ///
1980 ///   defaulted/deleted function-definition:
1981 ///     '=' 'default'
1982 ///     '=' 'delete'
1983 ///
1984 /// Prior to C++0x, the assignment-expression in an initializer-clause must
1985 /// be a constant-expression.
1986 ExprResult Parser::ParseCXXMemberInitializer(bool IsFunction,
1987                                              SourceLocation &EqualLoc) {
1988   assert((Tok.is(tok::equal) || Tok.is(tok::l_brace))
1989          && "Data member initializer not starting with '=' or '{'");
1990
1991   if (Tok.is(tok::equal)) {
1992     EqualLoc = ConsumeToken();
1993     if (Tok.is(tok::kw_delete)) {
1994       // In principle, an initializer of '= delete p;' is legal, but it will
1995       // never type-check. It's better to diagnose it as an ill-formed expression
1996       // than as an ill-formed deleted non-function member.
1997       // An initializer of '= delete p, foo' will never be parsed, because
1998       // a top-level comma always ends the initializer expression.
1999       const Token &Next = NextToken();
2000       if (IsFunction || Next.is(tok::semi) || Next.is(tok::comma) ||
2001            Next.is(tok::eof)) {
2002         if (IsFunction)
2003           Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
2004             << 1 /* delete */;
2005         else
2006           Diag(ConsumeToken(), diag::err_deleted_non_function);
2007         return ExprResult();
2008       }
2009     } else if (Tok.is(tok::kw_default)) {
2010       if (IsFunction)
2011         Diag(Tok, diag::err_default_delete_in_multiple_declaration)
2012           << 0 /* default */;
2013       else
2014         Diag(ConsumeToken(), diag::err_default_special_members);
2015       return ExprResult();
2016     }
2017
2018     return ParseInitializer();
2019   } else
2020     return ExprError(Diag(Tok, diag::err_generalized_initializer_lists));
2021 }
2022
2023 /// ParseCXXMemberSpecification - Parse the class definition.
2024 ///
2025 ///       member-specification:
2026 ///         member-declaration member-specification[opt]
2027 ///         access-specifier ':' member-specification[opt]
2028 ///
2029 void Parser::ParseCXXMemberSpecification(SourceLocation RecordLoc,
2030                                          unsigned TagType, Decl *TagDecl) {
2031   assert((TagType == DeclSpec::TST_struct ||
2032          TagType == DeclSpec::TST_union  ||
2033          TagType == DeclSpec::TST_class) && "Invalid TagType!");
2034
2035   PrettyDeclStackTraceEntry CrashInfo(Actions, TagDecl, RecordLoc,
2036                                       "parsing struct/union/class body");
2037
2038   // Determine whether this is a non-nested class. Note that local
2039   // classes are *not* considered to be nested classes.
2040   bool NonNestedClass = true;
2041   if (!ClassStack.empty()) {
2042     for (const Scope *S = getCurScope(); S; S = S->getParent()) {
2043       if (S->isClassScope()) {
2044         // We're inside a class scope, so this is a nested class.
2045         NonNestedClass = false;
2046         break;
2047       }
2048
2049       if ((S->getFlags() & Scope::FnScope)) {
2050         // If we're in a function or function template declared in the
2051         // body of a class, then this is a local class rather than a
2052         // nested class.
2053         const Scope *Parent = S->getParent();
2054         if (Parent->isTemplateParamScope())
2055           Parent = Parent->getParent();
2056         if (Parent->isClassScope())
2057           break;
2058       }
2059     }
2060   }
2061
2062   // Enter a scope for the class.
2063   ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope);
2064
2065   // Note that we are parsing a new (potentially-nested) class definition.
2066   ParsingClassDefinition ParsingDef(*this, TagDecl, NonNestedClass);
2067
2068   if (TagDecl)
2069     Actions.ActOnTagStartDefinition(getCurScope(), TagDecl);
2070
2071   SourceLocation FinalLoc;
2072
2073   // Parse the optional 'final' keyword.
2074   if (getLang().CPlusPlus && Tok.is(tok::identifier)) {
2075     IdentifierInfo *II = Tok.getIdentifierInfo();
2076
2077     // Initialize the contextual keywords.
2078     if (!Ident_final) {
2079       Ident_final = &PP.getIdentifierTable().get("final");
2080       Ident_override = &PP.getIdentifierTable().get("override");
2081     }
2082
2083     if (II == Ident_final)
2084       FinalLoc = ConsumeToken();
2085
2086     if (!getLang().CPlusPlus0x)
2087       Diag(FinalLoc, diag::ext_override_control_keyword) << "final";
2088   }
2089
2090   if (Tok.is(tok::colon)) {
2091     ParseBaseClause(TagDecl);
2092
2093     if (!Tok.is(tok::l_brace)) {
2094       Diag(Tok, diag::err_expected_lbrace_after_base_specifiers);
2095
2096       if (TagDecl)
2097         Actions.ActOnTagDefinitionError(getCurScope(), TagDecl);
2098       return;
2099     }
2100   }
2101
2102   assert(Tok.is(tok::l_brace));
2103   BalancedDelimiterTracker T(*this, tok::l_brace);
2104   T.consumeOpen();
2105
2106   if (TagDecl)
2107     Actions.ActOnStartCXXMemberDeclarations(getCurScope(), TagDecl, FinalLoc,
2108                                             T.getOpenLocation());
2109
2110   // C++ 11p3: Members of a class defined with the keyword class are private
2111   // by default. Members of a class defined with the keywords struct or union
2112   // are public by default.
2113   AccessSpecifier CurAS;
2114   if (TagType == DeclSpec::TST_class)
2115     CurAS = AS_private;
2116   else
2117     CurAS = AS_public;
2118   ParsedAttributes AccessAttrs(AttrFactory);
2119
2120   if (TagDecl) {
2121     // While we still have something to read, read the member-declarations.
2122     while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
2123       // Each iteration of this loop reads one member-declaration.
2124
2125       if (getLang().MicrosoftExt && (Tok.is(tok::kw___if_exists) ||
2126           Tok.is(tok::kw___if_not_exists))) {
2127         ParseMicrosoftIfExistsClassDeclaration((DeclSpec::TST)TagType, CurAS);
2128         continue;
2129       }
2130
2131       // Check for extraneous top-level semicolon.
2132       if (Tok.is(tok::semi)) {
2133         Diag(Tok, diag::ext_extra_struct_semi)
2134           << DeclSpec::getSpecifierName((DeclSpec::TST)TagType)
2135           << FixItHint::CreateRemoval(Tok.getLocation());
2136         ConsumeToken();
2137         continue;
2138       }
2139
2140       AccessSpecifier AS = getAccessSpecifierIfPresent();
2141       if (AS != AS_none) {
2142         // Current token is a C++ access specifier.
2143         CurAS = AS;
2144         SourceLocation ASLoc = Tok.getLocation();
2145         unsigned TokLength = Tok.getLength();
2146         ConsumeToken();
2147         AccessAttrs.clear();
2148         MaybeParseGNUAttributes(AccessAttrs);
2149
2150         SourceLocation EndLoc;
2151         if (Tok.is(tok::colon)) {
2152           EndLoc = Tok.getLocation();
2153           if (Actions.ActOnAccessSpecifier(AS, ASLoc, EndLoc,
2154                                            AccessAttrs.getList())) {
2155             // found another attribute than only annotations
2156             AccessAttrs.clear();
2157           }
2158           ConsumeToken();
2159         } else if (Tok.is(tok::semi)) {
2160           EndLoc = Tok.getLocation();
2161           ConsumeToken();
2162           Diag(EndLoc, diag::err_expected_colon)
2163             << FixItHint::CreateReplacement(EndLoc, ":");
2164         } else {
2165           EndLoc = ASLoc.getLocWithOffset(TokLength);
2166           Diag(EndLoc, diag::err_expected_colon)
2167             << FixItHint::CreateInsertion(EndLoc, ":");
2168         }
2169         Actions.ActOnAccessSpecifier(AS, ASLoc, EndLoc);
2170         continue;
2171       }
2172
2173       // FIXME: Make sure we don't have a template here.
2174
2175       // Parse all the comma separated declarators.
2176       ParseCXXClassMemberDeclaration(CurAS, AccessAttrs.getList());
2177     }
2178
2179     T.consumeClose();
2180   } else {
2181     SkipUntil(tok::r_brace, false, false);
2182   }
2183
2184   // If attributes exist after class contents, parse them.
2185   ParsedAttributes attrs(AttrFactory);
2186   MaybeParseGNUAttributes(attrs);
2187
2188   if (TagDecl)
2189     Actions.ActOnFinishCXXMemberSpecification(getCurScope(), RecordLoc, TagDecl,
2190                                               T.getOpenLocation(),
2191                                               T.getCloseLocation(),
2192                                               attrs.getList());
2193
2194   // C++0x [class.mem]p2: Within the class member-specification, the class is
2195   // regarded as complete within function bodies, default arguments, exception-
2196   // specifications, and brace-or-equal-initializers for non-static data
2197   // members (including such things in nested classes).
2198   //
2199   // FIXME: Only function bodies and brace-or-equal-initializers are currently
2200   // handled. Fix the others!
2201   if (TagDecl && NonNestedClass) {
2202     // We are not inside a nested class. This class and its nested classes
2203     // are complete and we can parse the delayed portions of method
2204     // declarations and the lexed inline method definitions, along with any
2205     // delayed attributes.
2206     SourceLocation SavedPrevTokLocation = PrevTokLocation;
2207     ParseLexedAttributes(getCurrentClass());
2208     ParseLexedMethodDeclarations(getCurrentClass());
2209     ParseLexedMemberInitializers(getCurrentClass());
2210     ParseLexedMethodDefs(getCurrentClass());
2211     PrevTokLocation = SavedPrevTokLocation;
2212   }
2213
2214   if (TagDecl)
2215     Actions.ActOnTagFinishDefinition(getCurScope(), TagDecl,
2216                                      T.getCloseLocation());
2217
2218   // Leave the class scope.
2219   ParsingDef.Pop();
2220   ClassScope.Exit();
2221 }
2222
2223 /// ParseConstructorInitializer - Parse a C++ constructor initializer,
2224 /// which explicitly initializes the members or base classes of a
2225 /// class (C++ [class.base.init]). For example, the three initializers
2226 /// after the ':' in the Derived constructor below:
2227 ///
2228 /// @code
2229 /// class Base { };
2230 /// class Derived : Base {
2231 ///   int x;
2232 ///   float f;
2233 /// public:
2234 ///   Derived(float f) : Base(), x(17), f(f) { }
2235 /// };
2236 /// @endcode
2237 ///
2238 /// [C++]  ctor-initializer:
2239 ///          ':' mem-initializer-list
2240 ///
2241 /// [C++]  mem-initializer-list:
2242 ///          mem-initializer ...[opt]
2243 ///          mem-initializer ...[opt] , mem-initializer-list
2244 void Parser::ParseConstructorInitializer(Decl *ConstructorDecl) {
2245   assert(Tok.is(tok::colon) && "Constructor initializer always starts with ':'");
2246
2247   // Poison the SEH identifiers so they are flagged as illegal in constructor initializers
2248   PoisonSEHIdentifiersRAIIObject PoisonSEHIdentifiers(*this, true);
2249   SourceLocation ColonLoc = ConsumeToken();
2250
2251   SmallVector<CXXCtorInitializer*, 4> MemInitializers;
2252   bool AnyErrors = false;
2253
2254   do {
2255     if (Tok.is(tok::code_completion)) {
2256       Actions.CodeCompleteConstructorInitializer(ConstructorDecl,
2257                                                  MemInitializers.data(),
2258                                                  MemInitializers.size());
2259       return cutOffParsing();
2260     } else {
2261       MemInitResult MemInit = ParseMemInitializer(ConstructorDecl);
2262       if (!MemInit.isInvalid())
2263         MemInitializers.push_back(MemInit.get());
2264       else
2265         AnyErrors = true;
2266     }
2267
2268     if (Tok.is(tok::comma))
2269       ConsumeToken();
2270     else if (Tok.is(tok::l_brace))
2271       break;
2272     // If the next token looks like a base or member initializer, assume that
2273     // we're just missing a comma.
2274     else if (Tok.is(tok::identifier) || Tok.is(tok::coloncolon)) {
2275       SourceLocation Loc = PP.getLocForEndOfToken(PrevTokLocation);
2276       Diag(Loc, diag::err_ctor_init_missing_comma)
2277         << FixItHint::CreateInsertion(Loc, ", ");
2278     } else {
2279       // Skip over garbage, until we get to '{'.  Don't eat the '{'.
2280       Diag(Tok.getLocation(), diag::err_expected_lbrace_or_comma);
2281       SkipUntil(tok::l_brace, true, true);
2282       break;
2283     }
2284   } while (true);
2285
2286   Actions.ActOnMemInitializers(ConstructorDecl, ColonLoc,
2287                                MemInitializers.data(), MemInitializers.size(),
2288                                AnyErrors);
2289 }
2290
2291 /// ParseMemInitializer - Parse a C++ member initializer, which is
2292 /// part of a constructor initializer that explicitly initializes one
2293 /// member or base class (C++ [class.base.init]). See
2294 /// ParseConstructorInitializer for an example.
2295 ///
2296 /// [C++] mem-initializer:
2297 ///         mem-initializer-id '(' expression-list[opt] ')'
2298 /// [C++0x] mem-initializer-id braced-init-list
2299 ///
2300 /// [C++] mem-initializer-id:
2301 ///         '::'[opt] nested-name-specifier[opt] class-name
2302 ///         identifier
2303 Parser::MemInitResult Parser::ParseMemInitializer(Decl *ConstructorDecl) {
2304   // parse '::'[opt] nested-name-specifier[opt]
2305   CXXScopeSpec SS;
2306   ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false);
2307   ParsedType TemplateTypeTy;
2308   if (Tok.is(tok::annot_template_id)) {
2309     TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
2310     if (TemplateId->Kind == TNK_Type_template ||
2311         TemplateId->Kind == TNK_Dependent_template_name) {
2312       AnnotateTemplateIdTokenAsType();
2313       assert(Tok.is(tok::annot_typename) && "template-id -> type failed");
2314       TemplateTypeTy = getTypeAnnotation(Tok);
2315     }
2316   }
2317   if (!TemplateTypeTy && Tok.isNot(tok::identifier)) {
2318     Diag(Tok, diag::err_expected_member_or_base_name);
2319     return true;
2320   }
2321
2322   // Get the identifier. This may be a member name or a class name,
2323   // but we'll let the semantic analysis determine which it is.
2324   IdentifierInfo *II = Tok.is(tok::identifier) ? Tok.getIdentifierInfo() : 0;
2325   SourceLocation IdLoc = ConsumeToken();
2326
2327   // Parse the '('.
2328   if (getLang().CPlusPlus0x && Tok.is(tok::l_brace)) {
2329     ExprResult InitList = ParseBraceInitializer();
2330     if (InitList.isInvalid())
2331       return true;
2332
2333     SourceLocation EllipsisLoc;
2334     if (Tok.is(tok::ellipsis))
2335       EllipsisLoc = ConsumeToken();
2336
2337     return Actions.ActOnMemInitializer(ConstructorDecl, getCurScope(), SS, II,
2338                                        TemplateTypeTy, IdLoc, InitList.take(),
2339                                        EllipsisLoc);
2340   } else if(Tok.is(tok::l_paren)) {
2341     BalancedDelimiterTracker T(*this, tok::l_paren);
2342     T.consumeOpen();
2343
2344     // Parse the optional expression-list.
2345     ExprVector ArgExprs(Actions);
2346     CommaLocsTy CommaLocs;
2347     if (Tok.isNot(tok::r_paren) && ParseExpressionList(ArgExprs, CommaLocs)) {
2348       SkipUntil(tok::r_paren);
2349       return true;
2350     }
2351
2352     T.consumeClose();
2353
2354     SourceLocation EllipsisLoc;
2355     if (Tok.is(tok::ellipsis))
2356       EllipsisLoc = ConsumeToken();
2357
2358     return Actions.ActOnMemInitializer(ConstructorDecl, getCurScope(), SS, II,
2359                                        TemplateTypeTy, IdLoc,
2360                                        T.getOpenLocation(), ArgExprs.take(),
2361                                        ArgExprs.size(), T.getCloseLocation(),
2362                                        EllipsisLoc);
2363   }
2364
2365   Diag(Tok, getLang().CPlusPlus0x ? diag::err_expected_lparen_or_lbrace
2366                                   : diag::err_expected_lparen);
2367   return true;
2368 }
2369
2370 /// \brief Parse a C++ exception-specification if present (C++0x [except.spec]).
2371 ///
2372 ///       exception-specification:
2373 ///         dynamic-exception-specification
2374 ///         noexcept-specification
2375 ///
2376 ///       noexcept-specification:
2377 ///         'noexcept'
2378 ///         'noexcept' '(' constant-expression ')'
2379 ExceptionSpecificationType
2380 Parser::MaybeParseExceptionSpecification(SourceRange &SpecificationRange,
2381                     SmallVectorImpl<ParsedType> &DynamicExceptions,
2382                     SmallVectorImpl<SourceRange> &DynamicExceptionRanges,
2383                     ExprResult &NoexceptExpr) {
2384   ExceptionSpecificationType Result = EST_None;
2385
2386   // See if there's a dynamic specification.
2387   if (Tok.is(tok::kw_throw)) {
2388     Result = ParseDynamicExceptionSpecification(SpecificationRange,
2389                                                 DynamicExceptions,
2390                                                 DynamicExceptionRanges);
2391     assert(DynamicExceptions.size() == DynamicExceptionRanges.size() &&
2392            "Produced different number of exception types and ranges.");
2393   }
2394
2395   // If there's no noexcept specification, we're done.
2396   if (Tok.isNot(tok::kw_noexcept))
2397     return Result;
2398
2399   // If we already had a dynamic specification, parse the noexcept for,
2400   // recovery, but emit a diagnostic and don't store the results.
2401   SourceRange NoexceptRange;
2402   ExceptionSpecificationType NoexceptType = EST_None;
2403
2404   SourceLocation KeywordLoc = ConsumeToken();
2405   if (Tok.is(tok::l_paren)) {
2406     // There is an argument.
2407     BalancedDelimiterTracker T(*this, tok::l_paren);
2408     T.consumeOpen();
2409     NoexceptType = EST_ComputedNoexcept;
2410     NoexceptExpr = ParseConstantExpression();
2411     // The argument must be contextually convertible to bool. We use
2412     // ActOnBooleanCondition for this purpose.
2413     if (!NoexceptExpr.isInvalid())
2414       NoexceptExpr = Actions.ActOnBooleanCondition(getCurScope(), KeywordLoc,
2415                                                    NoexceptExpr.get());
2416     T.consumeClose();
2417     NoexceptRange = SourceRange(KeywordLoc, T.getCloseLocation());
2418   } else {
2419     // There is no argument.
2420     NoexceptType = EST_BasicNoexcept;
2421     NoexceptRange = SourceRange(KeywordLoc, KeywordLoc);
2422   }
2423
2424   if (Result == EST_None) {
2425     SpecificationRange = NoexceptRange;
2426     Result = NoexceptType;
2427
2428     // If there's a dynamic specification after a noexcept specification,
2429     // parse that and ignore the results.
2430     if (Tok.is(tok::kw_throw)) {
2431       Diag(Tok.getLocation(), diag::err_dynamic_and_noexcept_specification);
2432       ParseDynamicExceptionSpecification(NoexceptRange, DynamicExceptions,
2433                                          DynamicExceptionRanges);
2434     }
2435   } else {
2436     Diag(Tok.getLocation(), diag::err_dynamic_and_noexcept_specification);
2437   }
2438
2439   return Result;
2440 }
2441
2442 /// ParseDynamicExceptionSpecification - Parse a C++
2443 /// dynamic-exception-specification (C++ [except.spec]).
2444 ///
2445 ///       dynamic-exception-specification:
2446 ///         'throw' '(' type-id-list [opt] ')'
2447 /// [MS]    'throw' '(' '...' ')'
2448 ///
2449 ///       type-id-list:
2450 ///         type-id ... [opt]
2451 ///         type-id-list ',' type-id ... [opt]
2452 ///
2453 ExceptionSpecificationType Parser::ParseDynamicExceptionSpecification(
2454                                   SourceRange &SpecificationRange,
2455                                   SmallVectorImpl<ParsedType> &Exceptions,
2456                                   SmallVectorImpl<SourceRange> &Ranges) {
2457   assert(Tok.is(tok::kw_throw) && "expected throw");
2458
2459   SpecificationRange.setBegin(ConsumeToken());
2460   BalancedDelimiterTracker T(*this, tok::l_paren);
2461   if (T.consumeOpen()) {
2462     Diag(Tok, diag::err_expected_lparen_after) << "throw";
2463     SpecificationRange.setEnd(SpecificationRange.getBegin());
2464     return EST_DynamicNone;
2465   }
2466
2467   // Parse throw(...), a Microsoft extension that means "this function
2468   // can throw anything".
2469   if (Tok.is(tok::ellipsis)) {
2470     SourceLocation EllipsisLoc = ConsumeToken();
2471     if (!getLang().MicrosoftExt)
2472       Diag(EllipsisLoc, diag::ext_ellipsis_exception_spec);
2473     T.consumeClose();
2474     SpecificationRange.setEnd(T.getCloseLocation());
2475     return EST_MSAny;
2476   }
2477
2478   // Parse the sequence of type-ids.
2479   SourceRange Range;
2480   while (Tok.isNot(tok::r_paren)) {
2481     TypeResult Res(ParseTypeName(&Range));
2482
2483     if (Tok.is(tok::ellipsis)) {
2484       // C++0x [temp.variadic]p5:
2485       //   - In a dynamic-exception-specification (15.4); the pattern is a
2486       //     type-id.
2487       SourceLocation Ellipsis = ConsumeToken();
2488       Range.setEnd(Ellipsis);
2489       if (!Res.isInvalid())
2490         Res = Actions.ActOnPackExpansion(Res.get(), Ellipsis);
2491     }
2492
2493     if (!Res.isInvalid()) {
2494       Exceptions.push_back(Res.get());
2495       Ranges.push_back(Range);
2496     }
2497
2498     if (Tok.is(tok::comma))
2499       ConsumeToken();
2500     else
2501       break;
2502   }
2503
2504   T.consumeClose();
2505   SpecificationRange.setEnd(T.getCloseLocation());
2506   return Exceptions.empty() ? EST_DynamicNone : EST_Dynamic;
2507 }
2508
2509 /// ParseTrailingReturnType - Parse a trailing return type on a new-style
2510 /// function declaration.
2511 TypeResult Parser::ParseTrailingReturnType(SourceRange &Range) {
2512   assert(Tok.is(tok::arrow) && "expected arrow");
2513
2514   ConsumeToken();
2515
2516   // FIXME: Need to suppress declarations when parsing this typename.
2517   // Otherwise in this function definition:
2518   //
2519   //   auto f() -> struct X {}
2520   //
2521   // struct X is parsed as class definition because of the trailing
2522   // brace.
2523   return ParseTypeName(&Range);
2524 }
2525
2526 /// \brief We have just started parsing the definition of a new class,
2527 /// so push that class onto our stack of classes that is currently
2528 /// being parsed.
2529 Sema::ParsingClassState
2530 Parser::PushParsingClass(Decl *ClassDecl, bool NonNestedClass) {
2531   assert((NonNestedClass || !ClassStack.empty()) &&
2532          "Nested class without outer class");
2533   ClassStack.push(new ParsingClass(ClassDecl, NonNestedClass));
2534   return Actions.PushParsingClass();
2535 }
2536
2537 /// \brief Deallocate the given parsed class and all of its nested
2538 /// classes.
2539 void Parser::DeallocateParsedClasses(Parser::ParsingClass *Class) {
2540   for (unsigned I = 0, N = Class->LateParsedDeclarations.size(); I != N; ++I)
2541     delete Class->LateParsedDeclarations[I];
2542   delete Class;
2543 }
2544
2545 /// \brief Pop the top class of the stack of classes that are
2546 /// currently being parsed.
2547 ///
2548 /// This routine should be called when we have finished parsing the
2549 /// definition of a class, but have not yet popped the Scope
2550 /// associated with the class's definition.
2551 ///
2552 /// \returns true if the class we've popped is a top-level class,
2553 /// false otherwise.
2554 void Parser::PopParsingClass(Sema::ParsingClassState state) {
2555   assert(!ClassStack.empty() && "Mismatched push/pop for class parsing");
2556
2557   Actions.PopParsingClass(state);
2558
2559   ParsingClass *Victim = ClassStack.top();
2560   ClassStack.pop();
2561   if (Victim->TopLevelClass) {
2562     // Deallocate all of the nested classes of this class,
2563     // recursively: we don't need to keep any of this information.
2564     DeallocateParsedClasses(Victim);
2565     return;
2566   }
2567   assert(!ClassStack.empty() && "Missing top-level class?");
2568
2569   if (Victim->LateParsedDeclarations.empty()) {
2570     // The victim is a nested class, but we will not need to perform
2571     // any processing after the definition of this class since it has
2572     // no members whose handling was delayed. Therefore, we can just
2573     // remove this nested class.
2574     DeallocateParsedClasses(Victim);
2575     return;
2576   }
2577
2578   // This nested class has some members that will need to be processed
2579   // after the top-level class is completely defined. Therefore, add
2580   // it to the list of nested classes within its parent.
2581   assert(getCurScope()->isClassScope() && "Nested class outside of class scope?");
2582   ClassStack.top()->LateParsedDeclarations.push_back(new LateParsedClass(this, Victim));
2583   Victim->TemplateScope = getCurScope()->getParent()->isTemplateParamScope();
2584 }
2585
2586 /// ParseCXX0XAttributeSpecifier - Parse a C++0x attribute-specifier. Currently
2587 /// only parses standard attributes.
2588 ///
2589 /// [C++0x] attribute-specifier:
2590 ///         '[' '[' attribute-list ']' ']'
2591 ///         alignment-specifier
2592 ///
2593 /// [C++0x] attribute-list:
2594 ///         attribute[opt]
2595 ///         attribute-list ',' attribute[opt]
2596 ///
2597 /// [C++0x] attribute:
2598 ///         attribute-token attribute-argument-clause[opt]
2599 ///
2600 /// [C++0x] attribute-token:
2601 ///         identifier
2602 ///         attribute-scoped-token
2603 ///
2604 /// [C++0x] attribute-scoped-token:
2605 ///         attribute-namespace '::' identifier
2606 ///
2607 /// [C++0x] attribute-namespace:
2608 ///         identifier
2609 ///
2610 /// [C++0x] attribute-argument-clause:
2611 ///         '(' balanced-token-seq ')'
2612 ///
2613 /// [C++0x] balanced-token-seq:
2614 ///         balanced-token
2615 ///         balanced-token-seq balanced-token
2616 ///
2617 /// [C++0x] balanced-token:
2618 ///         '(' balanced-token-seq ')'
2619 ///         '[' balanced-token-seq ']'
2620 ///         '{' balanced-token-seq '}'
2621 ///         any token but '(', ')', '[', ']', '{', or '}'
2622 void Parser::ParseCXX0XAttributeSpecifier(ParsedAttributes &attrs,
2623                                           SourceLocation *endLoc) {
2624   if (Tok.is(tok::kw_alignas)) {
2625     Diag(Tok.getLocation(), diag::warn_cxx98_compat_alignas);
2626     ParseAlignmentSpecifier(attrs, endLoc);
2627     return;
2628   }
2629
2630   assert(Tok.is(tok::l_square) && NextToken().is(tok::l_square)
2631       && "Not a C++0x attribute list");
2632
2633   Diag(Tok.getLocation(), diag::warn_cxx98_compat_attribute);
2634
2635   ConsumeBracket();
2636   ConsumeBracket();
2637
2638   if (Tok.is(tok::comma)) {
2639     Diag(Tok.getLocation(), diag::err_expected_ident);
2640     ConsumeToken();
2641   }
2642
2643   while (Tok.is(tok::identifier) || Tok.is(tok::comma)) {
2644     // attribute not present
2645     if (Tok.is(tok::comma)) {
2646       ConsumeToken();
2647       continue;
2648     }
2649
2650     IdentifierInfo *ScopeName = 0, *AttrName = Tok.getIdentifierInfo();
2651     SourceLocation ScopeLoc, AttrLoc = ConsumeToken();
2652
2653     // scoped attribute
2654     if (Tok.is(tok::coloncolon)) {
2655       ConsumeToken();
2656
2657       if (!Tok.is(tok::identifier)) {
2658         Diag(Tok.getLocation(), diag::err_expected_ident);
2659         SkipUntil(tok::r_square, tok::comma, true, true);
2660         continue;
2661       }
2662
2663       ScopeName = AttrName;
2664       ScopeLoc = AttrLoc;
2665
2666       AttrName = Tok.getIdentifierInfo();
2667       AttrLoc = ConsumeToken();
2668     }
2669
2670     bool AttrParsed = false;
2671     // No scoped names are supported; ideally we could put all non-standard
2672     // attributes into namespaces.
2673     if (!ScopeName) {
2674       switch(AttributeList::getKind(AttrName))
2675       {
2676       // No arguments
2677       case AttributeList::AT_carries_dependency:
2678       case AttributeList::AT_noreturn: {
2679         if (Tok.is(tok::l_paren)) {
2680           Diag(Tok.getLocation(), diag::err_cxx0x_attribute_forbids_arguments)
2681             << AttrName->getName();
2682           break;
2683         }
2684
2685         attrs.addNew(AttrName, AttrLoc, 0, AttrLoc, 0,
2686                      SourceLocation(), 0, 0, false, true);
2687         AttrParsed = true;
2688         break;
2689       }
2690
2691       // Silence warnings
2692       default: break;
2693       }
2694     }
2695
2696     // Skip the entire parameter clause, if any
2697     if (!AttrParsed && Tok.is(tok::l_paren)) {
2698       ConsumeParen();
2699       // SkipUntil maintains the balancedness of tokens.
2700       SkipUntil(tok::r_paren, false);
2701     }
2702   }
2703
2704   if (ExpectAndConsume(tok::r_square, diag::err_expected_rsquare))
2705     SkipUntil(tok::r_square, false);
2706   if (endLoc)
2707     *endLoc = Tok.getLocation();
2708   if (ExpectAndConsume(tok::r_square, diag::err_expected_rsquare))
2709     SkipUntil(tok::r_square, false);
2710 }
2711
2712 /// ParseCXX0XAttributes - Parse a C++0x attribute-specifier-seq.
2713 ///
2714 /// attribute-specifier-seq:
2715 ///       attribute-specifier-seq[opt] attribute-specifier
2716 void Parser::ParseCXX0XAttributes(ParsedAttributesWithRange &attrs,
2717                                   SourceLocation *endLoc) {
2718   SourceLocation StartLoc = Tok.getLocation(), Loc;
2719   if (!endLoc)
2720     endLoc = &Loc;
2721
2722   do {
2723     ParseCXX0XAttributeSpecifier(attrs, endLoc);
2724   } while (isCXX0XAttributeSpecifier());
2725
2726   attrs.Range = SourceRange(StartLoc, *endLoc);
2727 }
2728
2729 /// ParseMicrosoftAttributes - Parse a Microsoft attribute [Attr]
2730 ///
2731 /// [MS] ms-attribute:
2732 ///             '[' token-seq ']'
2733 ///
2734 /// [MS] ms-attribute-seq:
2735 ///             ms-attribute[opt]
2736 ///             ms-attribute ms-attribute-seq
2737 void Parser::ParseMicrosoftAttributes(ParsedAttributes &attrs,
2738                                       SourceLocation *endLoc) {
2739   assert(Tok.is(tok::l_square) && "Not a Microsoft attribute list");
2740
2741   while (Tok.is(tok::l_square)) {
2742     ConsumeBracket();
2743     SkipUntil(tok::r_square, true, true);
2744     if (endLoc) *endLoc = Tok.getLocation();
2745     ExpectAndConsume(tok::r_square, diag::err_expected_rsquare);
2746   }
2747 }
2748
2749 void Parser::ParseMicrosoftIfExistsClassDeclaration(DeclSpec::TST TagType,
2750                                                     AccessSpecifier& CurAS) {
2751   bool Result;
2752   if (ParseMicrosoftIfExistsCondition(Result))
2753     return;
2754
2755   if (Tok.isNot(tok::l_brace)) {
2756     Diag(Tok, diag::err_expected_lbrace);
2757     return;
2758   }
2759   ConsumeBrace();
2760
2761   // Condition is false skip all inside the {}.
2762   if (!Result) {
2763     SkipUntil(tok::r_brace, false);
2764     return;
2765   }
2766
2767   // Condition is true, parse the declaration.
2768   while (Tok.isNot(tok::r_brace)) {
2769
2770     // __if_exists, __if_not_exists can nest.
2771     if ((Tok.is(tok::kw___if_exists) || Tok.is(tok::kw___if_not_exists))) {
2772       ParseMicrosoftIfExistsClassDeclaration((DeclSpec::TST)TagType, CurAS);
2773       continue;
2774     }
2775
2776     // Check for extraneous top-level semicolon.
2777     if (Tok.is(tok::semi)) {
2778       Diag(Tok, diag::ext_extra_struct_semi)
2779         << DeclSpec::getSpecifierName((DeclSpec::TST)TagType)
2780         << FixItHint::CreateRemoval(Tok.getLocation());
2781       ConsumeToken();
2782       continue;
2783     }
2784
2785     AccessSpecifier AS = getAccessSpecifierIfPresent();
2786     if (AS != AS_none) {
2787       // Current token is a C++ access specifier.
2788       CurAS = AS;
2789       SourceLocation ASLoc = Tok.getLocation();
2790       ConsumeToken();
2791       if (Tok.is(tok::colon))
2792         Actions.ActOnAccessSpecifier(AS, ASLoc, Tok.getLocation());
2793       else
2794         Diag(Tok, diag::err_expected_colon);
2795       ConsumeToken();
2796       continue;
2797     }
2798
2799     // Parse all the comma separated declarators.
2800     ParseCXXClassMemberDeclaration(CurAS, 0);
2801   }
2802
2803   if (Tok.isNot(tok::r_brace)) {
2804     Diag(Tok, diag::err_expected_rbrace);
2805     return;
2806   }
2807   ConsumeBrace();
2808 }