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