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