1 //===--- ParseDeclCXX.cpp - C++ Declaration Parsing -----------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the C++ Declaration portions of the Parser interfaces.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Basic/OperatorKinds.h"
15 #include "clang/Parse/Parser.h"
16 #include "clang/Parse/ParseDiagnostic.h"
17 #include "clang/Sema/DeclSpec.h"
18 #include "clang/Sema/Scope.h"
19 #include "clang/Sema/ParsedTemplate.h"
20 #include "clang/Sema/PrettyDeclStackTrace.h"
21 #include "RAIIObjectsForParser.h"
22 using namespace clang;
24 /// ParseNamespace - We know that the current token is a namespace keyword. This
25 /// may either be a top level namespace or a block-level namespace alias. If
26 /// there was an inline keyword, it has already been parsed.
28 /// namespace-definition: [C++ 7.3: basic.namespace]
29 /// named-namespace-definition
30 /// unnamed-namespace-definition
32 /// unnamed-namespace-definition:
33 /// 'inline'[opt] 'namespace' attributes[opt] '{' namespace-body '}'
35 /// named-namespace-definition:
36 /// original-namespace-definition
37 /// extension-namespace-definition
39 /// original-namespace-definition:
40 /// 'inline'[opt] 'namespace' identifier attributes[opt]
41 /// '{' namespace-body '}'
43 /// extension-namespace-definition:
44 /// 'inline'[opt] 'namespace' original-namespace-name
45 /// '{' namespace-body '}'
47 /// namespace-alias-definition: [C++ 7.3.2: namespace.alias]
48 /// 'namespace' identifier '=' qualified-namespace-specifier ';'
50 Decl *Parser::ParseNamespace(unsigned Context,
51 SourceLocation &DeclEnd,
52 SourceLocation InlineLoc) {
53 assert(Tok.is(tok::kw_namespace) && "Not a namespace!");
54 SourceLocation NamespaceLoc = ConsumeToken(); // eat the 'namespace'.
55 ObjCDeclContextSwitch ObjCDC(*this);
57 if (Tok.is(tok::code_completion)) {
58 Actions.CodeCompleteNamespaceDecl(getCurScope());
63 SourceLocation IdentLoc;
64 IdentifierInfo *Ident = 0;
65 std::vector<SourceLocation> ExtraIdentLoc;
66 std::vector<IdentifierInfo*> ExtraIdent;
67 std::vector<SourceLocation> ExtraNamespaceLoc;
71 if (Tok.is(tok::identifier)) {
72 Ident = Tok.getIdentifierInfo();
73 IdentLoc = ConsumeToken(); // eat the identifier.
74 while (Tok.is(tok::coloncolon) && NextToken().is(tok::identifier)) {
75 ExtraNamespaceLoc.push_back(ConsumeToken());
76 ExtraIdent.push_back(Tok.getIdentifierInfo());
77 ExtraIdentLoc.push_back(ConsumeToken());
81 // Read label attributes, if present.
82 ParsedAttributes attrs(AttrFactory);
83 if (Tok.is(tok::kw___attribute)) {
85 ParseGNUAttributes(attrs);
88 if (Tok.is(tok::equal)) {
90 Diag(attrTok, diag::err_unexpected_namespace_attributes_alias);
91 if (InlineLoc.isValid())
92 Diag(InlineLoc, diag::err_inline_namespace_alias)
93 << FixItHint::CreateRemoval(InlineLoc);
94 return ParseNamespaceAlias(NamespaceLoc, IdentLoc, Ident, DeclEnd);
98 BalancedDelimiterTracker T(*this, tok::l_brace);
99 if (T.consumeOpen()) {
100 if (!ExtraIdent.empty()) {
101 Diag(ExtraNamespaceLoc[0], diag::err_nested_namespaces_with_double_colon)
102 << SourceRange(ExtraNamespaceLoc.front(), ExtraIdentLoc.back());
104 Diag(Tok, Ident ? diag::err_expected_lbrace :
105 diag::err_expected_ident_lbrace);
109 if (getCurScope()->isClassScope() || getCurScope()->isTemplateParamScope() ||
110 getCurScope()->isInObjcMethodScope() || getCurScope()->getBlockParent() ||
111 getCurScope()->getFnParent()) {
112 if (!ExtraIdent.empty()) {
113 Diag(ExtraNamespaceLoc[0], diag::err_nested_namespaces_with_double_colon)
114 << SourceRange(ExtraNamespaceLoc.front(), ExtraIdentLoc.back());
116 Diag(T.getOpenLocation(), diag::err_namespace_nonnamespace_scope);
117 SkipUntil(tok::r_brace, false);
121 if (!ExtraIdent.empty()) {
122 TentativeParsingAction TPA(*this);
123 SkipUntil(tok::r_brace, /*StopAtSemi*/false, /*DontConsume*/true);
124 Token rBraceToken = Tok;
127 if (!rBraceToken.is(tok::r_brace)) {
128 Diag(ExtraNamespaceLoc[0], diag::err_nested_namespaces_with_double_colon)
129 << SourceRange(ExtraNamespaceLoc.front(), ExtraIdentLoc.back());
131 std::string NamespaceFix;
132 for (std::vector<IdentifierInfo*>::iterator I = ExtraIdent.begin(),
133 E = ExtraIdent.end(); I != E; ++I) {
134 NamespaceFix += " { namespace ";
135 NamespaceFix += (*I)->getName();
139 for (unsigned i = 0, e = ExtraIdent.size(); i != e; ++i)
142 Diag(ExtraNamespaceLoc[0], diag::err_nested_namespaces_with_double_colon)
143 << FixItHint::CreateReplacement(SourceRange(ExtraNamespaceLoc.front(),
144 ExtraIdentLoc.back()),
146 << FixItHint::CreateInsertion(rBraceToken.getLocation(), RBraces);
150 // If we're still good, complain about inline namespaces in non-C++0x now.
151 if (!getLang().CPlusPlus0x && InlineLoc.isValid())
152 Diag(InlineLoc, diag::ext_inline_namespace);
154 // Enter a scope for the namespace.
155 ParseScope NamespaceScope(this, Scope::DeclScope);
158 Actions.ActOnStartNamespaceDef(getCurScope(), InlineLoc, NamespaceLoc,
159 IdentLoc, Ident, T.getOpenLocation(),
162 PrettyDeclStackTraceEntry CrashInfo(Actions, NamespcDecl, NamespaceLoc,
163 "parsing namespace");
165 // Parse the contents of the namespace. This includes parsing recovery on
166 // any improperly nested namespaces.
167 ParseInnerNamespace(ExtraIdentLoc, ExtraIdent, ExtraNamespaceLoc, 0,
168 InlineLoc, attrs, T);
170 // Leave the namespace scope.
171 NamespaceScope.Exit();
173 DeclEnd = T.getCloseLocation();
174 Actions.ActOnFinishNamespaceDef(NamespcDecl, DeclEnd);
179 /// ParseInnerNamespace - Parse the contents of a namespace.
180 void Parser::ParseInnerNamespace(std::vector<SourceLocation>& IdentLoc,
181 std::vector<IdentifierInfo*>& Ident,
182 std::vector<SourceLocation>& NamespaceLoc,
183 unsigned int index, SourceLocation& InlineLoc,
184 ParsedAttributes& attrs,
185 BalancedDelimiterTracker &Tracker) {
186 if (index == Ident.size()) {
187 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
188 ParsedAttributesWithRange attrs(AttrFactory);
189 MaybeParseCXX0XAttributes(attrs);
190 MaybeParseMicrosoftAttributes(attrs);
191 ParseExternalDeclaration(attrs);
194 // The caller is what called check -- we are simply calling
196 Tracker.consumeClose();
201 // Parse improperly nested namespaces.
202 ParseScope NamespaceScope(this, Scope::DeclScope);
204 Actions.ActOnStartNamespaceDef(getCurScope(), SourceLocation(),
205 NamespaceLoc[index], IdentLoc[index],
206 Ident[index], Tracker.getOpenLocation(),
209 ParseInnerNamespace(IdentLoc, Ident, NamespaceLoc, ++index, InlineLoc,
212 NamespaceScope.Exit();
214 Actions.ActOnFinishNamespaceDef(NamespcDecl, Tracker.getCloseLocation());
217 /// ParseNamespaceAlias - Parse the part after the '=' in a namespace
218 /// alias definition.
220 Decl *Parser::ParseNamespaceAlias(SourceLocation NamespaceLoc,
221 SourceLocation AliasLoc,
222 IdentifierInfo *Alias,
223 SourceLocation &DeclEnd) {
224 assert(Tok.is(tok::equal) && "Not equal token");
226 ConsumeToken(); // eat the '='.
228 if (Tok.is(tok::code_completion)) {
229 Actions.CodeCompleteNamespaceAliasDecl(getCurScope());
235 // Parse (optional) nested-name-specifier.
236 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false);
238 if (SS.isInvalid() || Tok.isNot(tok::identifier)) {
239 Diag(Tok, diag::err_expected_namespace_name);
240 // Skip to end of the definition and eat the ';'.
241 SkipUntil(tok::semi);
246 IdentifierInfo *Ident = Tok.getIdentifierInfo();
247 SourceLocation IdentLoc = ConsumeToken();
250 DeclEnd = Tok.getLocation();
251 ExpectAndConsume(tok::semi, diag::err_expected_semi_after_namespace_name,
254 return Actions.ActOnNamespaceAliasDef(getCurScope(), NamespaceLoc, AliasLoc, Alias,
255 SS, IdentLoc, Ident);
258 /// ParseLinkage - We know that the current token is a string_literal
259 /// and just before that, that extern was seen.
261 /// linkage-specification: [C++ 7.5p2: dcl.link]
262 /// 'extern' string-literal '{' declaration-seq[opt] '}'
263 /// 'extern' string-literal declaration
265 Decl *Parser::ParseLinkage(ParsingDeclSpec &DS, unsigned Context) {
266 assert(Tok.is(tok::string_literal) && "Not a string literal!");
267 llvm::SmallString<8> LangBuffer;
268 bool Invalid = false;
269 StringRef Lang = PP.getSpelling(Tok, LangBuffer, &Invalid);
273 SourceLocation Loc = ConsumeStringToken();
275 ParseScope LinkageScope(this, Scope::DeclScope);
277 = Actions.ActOnStartLinkageSpecification(getCurScope(),
278 DS.getSourceRange().getBegin(),
280 Tok.is(tok::l_brace) ? Tok.getLocation()
283 ParsedAttributesWithRange attrs(AttrFactory);
284 MaybeParseCXX0XAttributes(attrs);
285 MaybeParseMicrosoftAttributes(attrs);
287 if (Tok.isNot(tok::l_brace)) {
288 // Reset the source range in DS, as the leading "extern"
289 // does not really belong to the inner declaration ...
290 DS.SetRangeStart(SourceLocation());
291 DS.SetRangeEnd(SourceLocation());
292 // ... but anyway remember that such an "extern" was seen.
293 DS.setExternInLinkageSpec(true);
294 ParseExternalDeclaration(attrs, &DS);
295 return Actions.ActOnFinishLinkageSpecification(getCurScope(), LinkageSpec,
301 ProhibitAttributes(attrs);
303 BalancedDelimiterTracker T(*this, tok::l_brace);
305 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
306 ParsedAttributesWithRange attrs(AttrFactory);
307 MaybeParseCXX0XAttributes(attrs);
308 MaybeParseMicrosoftAttributes(attrs);
309 ParseExternalDeclaration(attrs);
313 return Actions.ActOnFinishLinkageSpecification(getCurScope(), LinkageSpec,
314 T.getCloseLocation());
317 /// ParseUsingDirectiveOrDeclaration - Parse C++ using using-declaration or
318 /// using-directive. Assumes that current token is 'using'.
319 Decl *Parser::ParseUsingDirectiveOrDeclaration(unsigned Context,
320 const ParsedTemplateInfo &TemplateInfo,
321 SourceLocation &DeclEnd,
322 ParsedAttributesWithRange &attrs,
324 assert(Tok.is(tok::kw_using) && "Not using token");
325 ObjCDeclContextSwitch ObjCDC(*this);
328 SourceLocation UsingLoc = ConsumeToken();
330 if (Tok.is(tok::code_completion)) {
331 Actions.CodeCompleteUsing(getCurScope());
336 // 'using namespace' means this is a using-directive.
337 if (Tok.is(tok::kw_namespace)) {
338 // Template parameters are always an error here.
339 if (TemplateInfo.Kind) {
340 SourceRange R = TemplateInfo.getSourceRange();
341 Diag(UsingLoc, diag::err_templated_using_directive)
342 << R << FixItHint::CreateRemoval(R);
345 return ParseUsingDirective(Context, UsingLoc, DeclEnd, attrs);
348 // Otherwise, it must be a using-declaration or an alias-declaration.
350 // Using declarations can't have attributes.
351 ProhibitAttributes(attrs);
353 return ParseUsingDeclaration(Context, TemplateInfo, UsingLoc, DeclEnd,
357 /// ParseUsingDirective - Parse C++ using-directive, assumes
358 /// that current token is 'namespace' and 'using' was already parsed.
360 /// using-directive: [C++ 7.3.p4: namespace.udir]
361 /// 'using' 'namespace' ::[opt] nested-name-specifier[opt]
363 /// [GNU] using-directive:
364 /// 'using' 'namespace' ::[opt] nested-name-specifier[opt]
365 /// namespace-name attributes[opt] ;
367 Decl *Parser::ParseUsingDirective(unsigned Context,
368 SourceLocation UsingLoc,
369 SourceLocation &DeclEnd,
370 ParsedAttributes &attrs) {
371 assert(Tok.is(tok::kw_namespace) && "Not 'namespace' token");
374 SourceLocation NamespcLoc = ConsumeToken();
376 if (Tok.is(tok::code_completion)) {
377 Actions.CodeCompleteUsingDirective(getCurScope());
383 // Parse (optional) nested-name-specifier.
384 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false);
386 IdentifierInfo *NamespcName = 0;
387 SourceLocation IdentLoc = SourceLocation();
389 // Parse namespace-name.
390 if (SS.isInvalid() || Tok.isNot(tok::identifier)) {
391 Diag(Tok, diag::err_expected_namespace_name);
392 // If there was invalid namespace name, skip to end of decl, and eat ';'.
393 SkipUntil(tok::semi);
394 // FIXME: Are there cases, when we would like to call ActOnUsingDirective?
399 NamespcName = Tok.getIdentifierInfo();
400 IdentLoc = ConsumeToken();
402 // Parse (optional) attributes (most likely GNU strong-using extension).
403 bool GNUAttr = false;
404 if (Tok.is(tok::kw___attribute)) {
406 ParseGNUAttributes(attrs);
410 DeclEnd = Tok.getLocation();
411 ExpectAndConsume(tok::semi,
412 GNUAttr ? diag::err_expected_semi_after_attribute_list
413 : diag::err_expected_semi_after_namespace_name,
416 return Actions.ActOnUsingDirective(getCurScope(), UsingLoc, NamespcLoc, SS,
417 IdentLoc, NamespcName, attrs.getList());
420 /// ParseUsingDeclaration - Parse C++ using-declaration or alias-declaration.
421 /// Assumes that 'using' was already seen.
423 /// using-declaration: [C++ 7.3.p3: namespace.udecl]
424 /// 'using' 'typename'[opt] ::[opt] nested-name-specifier
426 /// 'using' :: unqualified-id
428 /// alias-declaration: C++0x [decl.typedef]p2
429 /// 'using' identifier = type-id ;
431 Decl *Parser::ParseUsingDeclaration(unsigned Context,
432 const ParsedTemplateInfo &TemplateInfo,
433 SourceLocation UsingLoc,
434 SourceLocation &DeclEnd,
438 SourceLocation TypenameLoc;
441 // Ignore optional 'typename'.
442 // FIXME: This is wrong; we should parse this as a typename-specifier.
443 if (Tok.is(tok::kw_typename)) {
444 TypenameLoc = Tok.getLocation();
451 // Parse nested-name-specifier.
452 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false);
454 // Check nested-name specifier.
455 if (SS.isInvalid()) {
456 SkipUntil(tok::semi);
460 // Parse the unqualified-id. We allow parsing of both constructor and
461 // destructor names and allow the action module to diagnose any semantic
464 if (ParseUnqualifiedId(SS,
465 /*EnteringContext=*/false,
466 /*AllowDestructorName=*/true,
467 /*AllowConstructorName=*/true,
470 SkipUntil(tok::semi);
474 ParsedAttributes attrs(AttrFactory);
476 // Maybe this is an alias-declaration.
477 bool IsAliasDecl = Tok.is(tok::equal);
478 TypeResult TypeAlias;
480 // TODO: Attribute support. C++0x attributes may appear before the equals.
481 // Where can GNU attributes appear?
484 if (!getLang().CPlusPlus0x)
485 Diag(Tok.getLocation(), diag::ext_alias_declaration);
487 // Type alias templates cannot be specialized.
489 if (TemplateInfo.Kind == ParsedTemplateInfo::Template &&
490 Name.getKind() == UnqualifiedId::IK_TemplateId)
492 if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization)
494 if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation)
496 if (SpecKind != -1) {
499 Range = SourceRange(Name.TemplateId->LAngleLoc,
500 Name.TemplateId->RAngleLoc);
502 Range = TemplateInfo.getSourceRange();
503 Diag(Range.getBegin(), diag::err_alias_declaration_specialization)
504 << SpecKind << Range;
505 SkipUntil(tok::semi);
509 // Name must be an identifier.
510 if (Name.getKind() != UnqualifiedId::IK_Identifier) {
511 Diag(Name.StartLocation, diag::err_alias_declaration_not_identifier);
512 // No removal fixit: can't recover from this.
513 SkipUntil(tok::semi);
515 } else if (IsTypeName)
516 Diag(TypenameLoc, diag::err_alias_declaration_not_identifier)
517 << FixItHint::CreateRemoval(SourceRange(TypenameLoc,
518 SS.isNotEmpty() ? SS.getEndLoc() : TypenameLoc));
519 else if (SS.isNotEmpty())
520 Diag(SS.getBeginLoc(), diag::err_alias_declaration_not_identifier)
521 << FixItHint::CreateRemoval(SS.getRange());
523 TypeAlias = ParseTypeName(0, TemplateInfo.Kind ?
524 Declarator::AliasTemplateContext :
525 Declarator::AliasDeclContext, AS, OwnedType);
527 // Parse (optional) attributes (most likely GNU strong-using extension).
528 MaybeParseGNUAttributes(attrs);
531 DeclEnd = Tok.getLocation();
532 ExpectAndConsume(tok::semi, diag::err_expected_semi_after,
533 !attrs.empty() ? "attributes list" :
534 IsAliasDecl ? "alias declaration" : "using declaration",
537 // Diagnose an attempt to declare a templated using-declaration.
538 // In C++0x, alias-declarations can be templates:
539 // template <...> using id = type;
540 if (TemplateInfo.Kind && !IsAliasDecl) {
541 SourceRange R = TemplateInfo.getSourceRange();
542 Diag(UsingLoc, diag::err_templated_using_declaration)
543 << R << FixItHint::CreateRemoval(R);
545 // Unfortunately, we have to bail out instead of recovering by
546 // ignoring the parameters, just in case the nested name specifier
547 // depends on the parameters.
551 // "typename" keyword is allowed for identifiers only,
552 // because it may be a type definition.
553 if (IsTypeName && Name.getKind() != UnqualifiedId::IK_Identifier) {
554 Diag(Name.getSourceRange().getBegin(), diag::err_typename_identifiers_only)
555 << FixItHint::CreateRemoval(SourceRange(TypenameLoc));
556 // Proceed parsing, but reset the IsTypeName flag.
561 TemplateParameterLists *TemplateParams = TemplateInfo.TemplateParams;
562 MultiTemplateParamsArg TemplateParamsArg(Actions,
563 TemplateParams ? TemplateParams->data() : 0,
564 TemplateParams ? TemplateParams->size() : 0);
565 return Actions.ActOnAliasDeclaration(getCurScope(), AS, TemplateParamsArg,
566 UsingLoc, Name, TypeAlias);
569 return Actions.ActOnUsingDeclaration(getCurScope(), AS, true, UsingLoc, SS,
570 Name, attrs.getList(),
571 IsTypeName, TypenameLoc);
574 /// ParseStaticAssertDeclaration - Parse C++0x or C1X static_assert-declaration.
576 /// [C++0x] static_assert-declaration:
577 /// static_assert ( constant-expression , string-literal ) ;
579 /// [C1X] static_assert-declaration:
580 /// _Static_assert ( constant-expression , string-literal ) ;
582 Decl *Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd){
583 assert((Tok.is(tok::kw_static_assert) || Tok.is(tok::kw__Static_assert)) &&
584 "Not a static_assert declaration");
586 if (Tok.is(tok::kw__Static_assert) && !getLang().C1X)
587 Diag(Tok, diag::ext_c1x_static_assert);
589 SourceLocation StaticAssertLoc = ConsumeToken();
591 BalancedDelimiterTracker T(*this, tok::l_paren);
592 if (T.consumeOpen()) {
593 Diag(Tok, diag::err_expected_lparen);
597 ExprResult AssertExpr(ParseConstantExpression());
598 if (AssertExpr.isInvalid()) {
599 SkipUntil(tok::semi);
603 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "", tok::semi))
606 if (Tok.isNot(tok::string_literal)) {
607 Diag(Tok, diag::err_expected_string_literal);
608 SkipUntil(tok::semi);
612 ExprResult AssertMessage(ParseStringLiteralExpression());
613 if (AssertMessage.isInvalid())
618 DeclEnd = Tok.getLocation();
619 ExpectAndConsumeSemi(diag::err_expected_semi_after_static_assert);
621 return Actions.ActOnStaticAssertDeclaration(StaticAssertLoc,
623 AssertMessage.take(),
624 T.getCloseLocation());
627 /// ParseDecltypeSpecifier - Parse a C++0x decltype specifier.
629 /// 'decltype' ( expression )
631 void Parser::ParseDecltypeSpecifier(DeclSpec &DS) {
632 assert(Tok.is(tok::kw_decltype) && "Not a decltype specifier");
634 SourceLocation StartLoc = ConsumeToken();
635 BalancedDelimiterTracker T(*this, tok::l_paren);
636 if (T.expectAndConsume(diag::err_expected_lparen_after,
637 "decltype", tok::r_paren)) {
641 // Parse the expression
643 // C++0x [dcl.type.simple]p4:
644 // The operand of the decltype specifier is an unevaluated operand.
645 EnterExpressionEvaluationContext Unevaluated(Actions,
647 ExprResult Result = ParseExpression();
648 if (Result.isInvalid()) {
649 SkipUntil(tok::r_paren);
655 if (T.getCloseLocation().isInvalid())
658 const char *PrevSpec = 0;
660 // Check for duplicate type specifiers (e.g. "int decltype(a)").
661 if (DS.SetTypeSpecType(DeclSpec::TST_decltype, StartLoc, PrevSpec,
662 DiagID, Result.release()))
663 Diag(StartLoc, DiagID) << PrevSpec;
666 void Parser::ParseUnderlyingTypeSpecifier(DeclSpec &DS) {
667 assert(Tok.is(tok::kw___underlying_type) &&
668 "Not an underlying type specifier");
670 SourceLocation StartLoc = ConsumeToken();
671 BalancedDelimiterTracker T(*this, tok::l_paren);
672 if (T.expectAndConsume(diag::err_expected_lparen_after,
673 "__underlying_type", tok::r_paren)) {
677 TypeResult Result = ParseTypeName();
678 if (Result.isInvalid()) {
679 SkipUntil(tok::r_paren);
685 if (T.getCloseLocation().isInvalid())
688 const char *PrevSpec = 0;
690 if (DS.SetTypeSpecType(DeclSpec::TST_underlyingType, StartLoc, PrevSpec,
691 DiagID, Result.release()))
692 Diag(StartLoc, DiagID) << PrevSpec;
695 /// ParseClassName - Parse a C++ class-name, which names a class. Note
696 /// that we only check that the result names a type; semantic analysis
697 /// will need to verify that the type names a class. The result is
698 /// either a type or NULL, depending on whether a type name was
701 /// class-name: [C++ 9.1]
703 /// simple-template-id
705 Parser::TypeResult Parser::ParseClassName(SourceLocation &EndLocation,
707 // Check whether we have a template-id that names a type.
708 if (Tok.is(tok::annot_template_id)) {
709 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
710 if (TemplateId->Kind == TNK_Type_template ||
711 TemplateId->Kind == TNK_Dependent_template_name) {
712 AnnotateTemplateIdTokenAsType();
714 assert(Tok.is(tok::annot_typename) && "template-id -> type failed");
715 ParsedType Type = getTypeAnnotation(Tok);
716 EndLocation = Tok.getAnnotationEndLoc();
724 // Fall through to produce an error below.
727 if (Tok.isNot(tok::identifier)) {
728 Diag(Tok, diag::err_expected_class_name);
732 IdentifierInfo *Id = Tok.getIdentifierInfo();
733 SourceLocation IdLoc = ConsumeToken();
735 if (Tok.is(tok::less)) {
736 // It looks the user intended to write a template-id here, but the
737 // template-name was wrong. Try to fix that.
738 TemplateNameKind TNK = TNK_Type_template;
740 if (!Actions.DiagnoseUnknownTemplateName(*Id, IdLoc, getCurScope(),
741 &SS, Template, TNK)) {
742 Diag(IdLoc, diag::err_unknown_template_name)
749 // Form the template name
750 UnqualifiedId TemplateName;
751 TemplateName.setIdentifier(Id, IdLoc);
753 // Parse the full template-id, then turn it into a type.
754 if (AnnotateTemplateIdToken(Template, TNK, SS, TemplateName,
755 SourceLocation(), true))
757 if (TNK == TNK_Dependent_template_name)
758 AnnotateTemplateIdTokenAsType();
760 // If we didn't end up with a typename token, there's nothing more we
762 if (Tok.isNot(tok::annot_typename))
765 // Retrieve the type from the annotation token, consume that token, and
767 EndLocation = Tok.getAnnotationEndLoc();
768 ParsedType Type = getTypeAnnotation(Tok);
773 // We have an identifier; check whether it is actually a type.
774 ParsedType Type = Actions.getTypeName(*Id, IdLoc, getCurScope(), &SS, true,
776 /*NonTrivialTypeSourceInfo=*/true);
778 Diag(IdLoc, diag::err_expected_class_name);
782 // Consume the identifier.
785 // Fake up a Declarator to use with ActOnTypeName.
786 DeclSpec DS(AttrFactory);
787 DS.SetRangeStart(IdLoc);
788 DS.SetRangeEnd(EndLocation);
789 DS.getTypeSpecScope() = SS;
791 const char *PrevSpec = 0;
793 DS.SetTypeSpecType(TST_typename, IdLoc, PrevSpec, DiagID, Type);
795 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
796 return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
799 /// ParseClassSpecifier - Parse a C++ class-specifier [C++ class] or
800 /// elaborated-type-specifier [C++ dcl.type.elab]; we can't tell which
801 /// until we reach the start of a definition or see a token that
802 /// cannot start a definition. If SuppressDeclarations is true, we do know.
804 /// class-specifier: [C++ class]
805 /// class-head '{' member-specification[opt] '}'
806 /// class-head '{' member-specification[opt] '}' attributes[opt]
808 /// class-key identifier[opt] base-clause[opt]
809 /// class-key nested-name-specifier identifier base-clause[opt]
810 /// class-key nested-name-specifier[opt] simple-template-id
812 /// [GNU] class-key attributes[opt] identifier[opt] base-clause[opt]
813 /// [GNU] class-key attributes[opt] nested-name-specifier
814 /// identifier base-clause[opt]
815 /// [GNU] class-key attributes[opt] nested-name-specifier[opt]
816 /// simple-template-id base-clause[opt]
822 /// elaborated-type-specifier: [C++ dcl.type.elab]
823 /// class-key ::[opt] nested-name-specifier[opt] identifier
824 /// class-key ::[opt] nested-name-specifier[opt] 'template'[opt]
825 /// simple-template-id
827 /// Note that the C++ class-specifier and elaborated-type-specifier,
828 /// together, subsume the C99 struct-or-union-specifier:
830 /// struct-or-union-specifier: [C99 6.7.2.1]
831 /// struct-or-union identifier[opt] '{' struct-contents '}'
832 /// struct-or-union identifier
833 /// [GNU] struct-or-union attributes[opt] identifier[opt] '{' struct-contents
834 /// '}' attributes[opt]
835 /// [GNU] struct-or-union attributes[opt] identifier
839 void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
840 SourceLocation StartLoc, DeclSpec &DS,
841 const ParsedTemplateInfo &TemplateInfo,
842 AccessSpecifier AS, bool SuppressDeclarations){
843 DeclSpec::TST TagType;
844 if (TagTokKind == tok::kw_struct)
845 TagType = DeclSpec::TST_struct;
846 else if (TagTokKind == tok::kw_class)
847 TagType = DeclSpec::TST_class;
849 assert(TagTokKind == tok::kw_union && "Not a class specifier");
850 TagType = DeclSpec::TST_union;
853 if (Tok.is(tok::code_completion)) {
854 // Code completion for a struct, class, or union name.
855 Actions.CodeCompleteTag(getCurScope(), TagType);
856 return cutOffParsing();
859 // C++03 [temp.explicit] 14.7.2/8:
860 // The usual access checking rules do not apply to names used to specify
861 // explicit instantiations.
863 // As an extension we do not perform access checking on the names used to
864 // specify explicit specializations either. This is important to allow
865 // specializing traits classes for private types.
866 bool SuppressingAccessChecks = false;
867 if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
868 TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization) {
869 Actions.ActOnStartSuppressingAccessChecks();
870 SuppressingAccessChecks = true;
873 ParsedAttributes attrs(AttrFactory);
874 // If attributes exist after tag, parse them.
875 if (Tok.is(tok::kw___attribute))
876 ParseGNUAttributes(attrs);
878 // If declspecs exist after tag, parse them.
879 while (Tok.is(tok::kw___declspec))
880 ParseMicrosoftDeclSpec(attrs);
882 // If C++0x attributes exist here, parse them.
883 // FIXME: Are we consistent with the ordering of parsing of different
884 // styles of attributes?
885 MaybeParseCXX0XAttributes(attrs);
887 if (TagType == DeclSpec::TST_struct &&
888 !Tok.is(tok::identifier) &&
889 Tok.getIdentifierInfo() &&
890 (Tok.is(tok::kw___is_arithmetic) ||
891 Tok.is(tok::kw___is_convertible) ||
892 Tok.is(tok::kw___is_empty) ||
893 Tok.is(tok::kw___is_floating_point) ||
894 Tok.is(tok::kw___is_function) ||
895 Tok.is(tok::kw___is_fundamental) ||
896 Tok.is(tok::kw___is_integral) ||
897 Tok.is(tok::kw___is_member_function_pointer) ||
898 Tok.is(tok::kw___is_member_pointer) ||
899 Tok.is(tok::kw___is_pod) ||
900 Tok.is(tok::kw___is_pointer) ||
901 Tok.is(tok::kw___is_same) ||
902 Tok.is(tok::kw___is_scalar) ||
903 Tok.is(tok::kw___is_signed) ||
904 Tok.is(tok::kw___is_unsigned) ||
905 Tok.is(tok::kw___is_void))) {
906 // GNU libstdc++ 4.2 and libc++ use certain intrinsic names as the
907 // name of struct templates, but some are keywords in GCC >= 4.3
908 // and Clang. Therefore, when we see the token sequence "struct
909 // X", make X into a normal identifier rather than a keyword, to
910 // allow libstdc++ 4.2 and libc++ to work properly.
911 Tok.getIdentifierInfo()->RevertTokenIDToIdentifier();
912 Tok.setKind(tok::identifier);
915 // Parse the (optional) nested-name-specifier.
916 CXXScopeSpec &SS = DS.getTypeSpecScope();
917 if (getLang().CPlusPlus) {
918 // "FOO : BAR" is not a potential typo for "FOO::BAR".
919 ColonProtectionRAIIObject X(*this);
921 if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), true))
922 DS.SetTypeSpecError();
924 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::annot_template_id))
925 Diag(Tok, diag::err_expected_ident);
928 TemplateParameterLists *TemplateParams = TemplateInfo.TemplateParams;
930 // Parse the (optional) class name or simple-template-id.
931 IdentifierInfo *Name = 0;
932 SourceLocation NameLoc;
933 TemplateIdAnnotation *TemplateId = 0;
934 if (Tok.is(tok::identifier)) {
935 Name = Tok.getIdentifierInfo();
936 NameLoc = ConsumeToken();
938 if (Tok.is(tok::less) && getLang().CPlusPlus) {
939 // The name was supposed to refer to a template, but didn't.
940 // Eat the template argument list and try to continue parsing this as
941 // a class (or template thereof).
942 TemplateArgList TemplateArgs;
943 SourceLocation LAngleLoc, RAngleLoc;
944 if (ParseTemplateIdAfterTemplateName(TemplateTy(), NameLoc, SS,
946 TemplateArgs, RAngleLoc)) {
947 // We couldn't parse the template argument list at all, so don't
948 // try to give any location information for the list.
949 LAngleLoc = RAngleLoc = SourceLocation();
952 Diag(NameLoc, diag::err_explicit_spec_non_template)
953 << (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation)
954 << (TagType == DeclSpec::TST_class? 0
955 : TagType == DeclSpec::TST_struct? 1
958 << SourceRange(LAngleLoc, RAngleLoc);
960 // Strip off the last template parameter list if it was empty, since
961 // we've removed its template argument list.
962 if (TemplateParams && TemplateInfo.LastParameterListWasEmpty) {
963 if (TemplateParams && TemplateParams->size() > 1) {
964 TemplateParams->pop_back();
967 const_cast<ParsedTemplateInfo&>(TemplateInfo).Kind
968 = ParsedTemplateInfo::NonTemplate;
970 } else if (TemplateInfo.Kind
971 == ParsedTemplateInfo::ExplicitInstantiation) {
972 // Pretend this is just a forward declaration.
974 const_cast<ParsedTemplateInfo&>(TemplateInfo).Kind
975 = ParsedTemplateInfo::NonTemplate;
976 const_cast<ParsedTemplateInfo&>(TemplateInfo).TemplateLoc
978 const_cast<ParsedTemplateInfo&>(TemplateInfo).ExternLoc
982 } else if (Tok.is(tok::annot_template_id)) {
983 TemplateId = takeTemplateIdAnnotation(Tok);
984 NameLoc = ConsumeToken();
986 if (TemplateId->Kind != TNK_Type_template &&
987 TemplateId->Kind != TNK_Dependent_template_name) {
988 // The template-name in the simple-template-id refers to
989 // something other than a class template. Give an appropriate
990 // error message and skip to the ';'.
991 SourceRange Range(NameLoc);
993 Range.setBegin(SS.getBeginLoc());
995 Diag(TemplateId->LAngleLoc, diag::err_template_spec_syntax_non_template)
996 << Name << static_cast<int>(TemplateId->Kind) << Range;
998 DS.SetTypeSpecError();
999 SkipUntil(tok::semi, false, true);
1000 if (SuppressingAccessChecks)
1001 Actions.ActOnStopSuppressingAccessChecks();
1007 // As soon as we're finished parsing the class's template-id, turn access
1008 // checking back on.
1009 if (SuppressingAccessChecks)
1010 Actions.ActOnStopSuppressingAccessChecks();
1012 // There are four options here. If we have 'struct foo;', then this
1013 // is either a forward declaration or a friend declaration, which
1014 // have to be treated differently. If we have 'struct foo {...',
1015 // 'struct foo :...' or 'struct foo final[opt]' then this is a
1016 // definition. Otherwise we have something like 'struct foo xyz', a reference.
1017 // However, in some contexts, things look like declarations but are just
1021 // &T::operator struct s;
1022 // For these, SuppressDeclarations is true.
1023 Sema::TagUseKind TUK;
1024 if (SuppressDeclarations)
1025 TUK = Sema::TUK_Reference;
1026 else if (Tok.is(tok::l_brace) ||
1027 (getLang().CPlusPlus && Tok.is(tok::colon)) ||
1028 isCXX0XFinalKeyword()) {
1029 if (DS.isFriendSpecified()) {
1030 // C++ [class.friend]p2:
1031 // A class shall not be defined in a friend declaration.
1032 Diag(Tok.getLocation(), diag::err_friend_decl_defines_class)
1033 << SourceRange(DS.getFriendSpecLoc());
1035 // Skip everything up to the semicolon, so that this looks like a proper
1036 // friend class (or template thereof) declaration.
1037 SkipUntil(tok::semi, true, true);
1038 TUK = Sema::TUK_Friend;
1040 // Okay, this is a class definition.
1041 TUK = Sema::TUK_Definition;
1043 } else if (Tok.is(tok::semi))
1044 TUK = DS.isFriendSpecified() ? Sema::TUK_Friend : Sema::TUK_Declaration;
1046 TUK = Sema::TUK_Reference;
1048 if (!Name && !TemplateId && (DS.getTypeSpecType() == DeclSpec::TST_error ||
1049 TUK != Sema::TUK_Definition)) {
1050 if (DS.getTypeSpecType() != DeclSpec::TST_error) {
1051 // We have a declaration or reference to an anonymous class.
1052 Diag(StartLoc, diag::err_anon_type_definition)
1053 << DeclSpec::getSpecifierName(TagType);
1056 SkipUntil(tok::comma, true);
1060 // Create the tag portion of the class or class template.
1061 DeclResult TagOrTempResult = true; // invalid
1062 TypeResult TypeResult = true; // invalid
1066 // Explicit specialization, class template partial specialization,
1067 // or explicit instantiation.
1068 ASTTemplateArgsPtr TemplateArgsPtr(Actions,
1069 TemplateId->getTemplateArgs(),
1070 TemplateId->NumArgs);
1071 if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation &&
1072 TUK == Sema::TUK_Declaration) {
1073 // This is an explicit instantiation of a class template.
1075 = Actions.ActOnExplicitInstantiation(getCurScope(),
1076 TemplateInfo.ExternLoc,
1077 TemplateInfo.TemplateLoc,
1081 TemplateId->Template,
1082 TemplateId->TemplateNameLoc,
1083 TemplateId->LAngleLoc,
1085 TemplateId->RAngleLoc,
1088 // Friend template-ids are treated as references unless
1089 // they have template headers, in which case they're ill-formed
1090 // (FIXME: "template <class T> friend class A<T>::B<int>;").
1091 // We diagnose this error in ActOnClassTemplateSpecialization.
1092 } else if (TUK == Sema::TUK_Reference ||
1093 (TUK == Sema::TUK_Friend &&
1094 TemplateInfo.Kind == ParsedTemplateInfo::NonTemplate)) {
1095 TypeResult = Actions.ActOnTagTemplateIdType(TUK, TagType,
1098 TemplateId->Template,
1099 TemplateId->TemplateNameLoc,
1100 TemplateId->LAngleLoc,
1102 TemplateId->RAngleLoc);
1104 // This is an explicit specialization or a class template
1105 // partial specialization.
1106 TemplateParameterLists FakedParamLists;
1108 if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) {
1109 // This looks like an explicit instantiation, because we have
1112 // template class Foo<X>
1114 // but it actually has a definition. Most likely, this was
1115 // meant to be an explicit specialization, but the user forgot
1116 // the '<>' after 'template'.
1117 assert(TUK == Sema::TUK_Definition && "Expected a definition here");
1119 SourceLocation LAngleLoc
1120 = PP.getLocForEndOfToken(TemplateInfo.TemplateLoc);
1121 Diag(TemplateId->TemplateNameLoc,
1122 diag::err_explicit_instantiation_with_definition)
1123 << SourceRange(TemplateInfo.TemplateLoc)
1124 << FixItHint::CreateInsertion(LAngleLoc, "<>");
1126 // Create a fake template parameter list that contains only
1127 // "template<>", so that we treat this construct as a class
1128 // template specialization.
1129 FakedParamLists.push_back(
1130 Actions.ActOnTemplateParameterList(0, SourceLocation(),
1131 TemplateInfo.TemplateLoc,
1135 TemplateParams = &FakedParamLists;
1138 // Build the class template specialization.
1140 = Actions.ActOnClassTemplateSpecialization(getCurScope(), TagType, TUK,
1141 StartLoc, DS.getModulePrivateSpecLoc(), SS,
1142 TemplateId->Template,
1143 TemplateId->TemplateNameLoc,
1144 TemplateId->LAngleLoc,
1146 TemplateId->RAngleLoc,
1148 MultiTemplateParamsArg(Actions,
1149 TemplateParams? &(*TemplateParams)[0] : 0,
1150 TemplateParams? TemplateParams->size() : 0));
1152 } else if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation &&
1153 TUK == Sema::TUK_Declaration) {
1154 // Explicit instantiation of a member of a class template
1155 // specialization, e.g.,
1157 // template struct Outer<int>::Inner;
1160 = Actions.ActOnExplicitInstantiation(getCurScope(),
1161 TemplateInfo.ExternLoc,
1162 TemplateInfo.TemplateLoc,
1163 TagType, StartLoc, SS, Name,
1164 NameLoc, attrs.getList());
1165 } else if (TUK == Sema::TUK_Friend &&
1166 TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate) {
1168 Actions.ActOnTemplatedFriendTag(getCurScope(), DS.getFriendSpecLoc(),
1169 TagType, StartLoc, SS,
1170 Name, NameLoc, attrs.getList(),
1171 MultiTemplateParamsArg(Actions,
1172 TemplateParams? &(*TemplateParams)[0] : 0,
1173 TemplateParams? TemplateParams->size() : 0));
1175 if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation &&
1176 TUK == Sema::TUK_Definition) {
1177 // FIXME: Diagnose this particular error.
1180 bool IsDependent = false;
1182 // Don't pass down template parameter lists if this is just a tag
1183 // reference. For example, we don't need the template parameters here:
1184 // template <class T> class A *makeA(T t);
1185 MultiTemplateParamsArg TParams;
1186 if (TUK != Sema::TUK_Reference && TemplateParams)
1188 MultiTemplateParamsArg(&(*TemplateParams)[0], TemplateParams->size());
1190 // Declaration or definition of a class type
1191 TagOrTempResult = Actions.ActOnTag(getCurScope(), TagType, TUK, StartLoc,
1192 SS, Name, NameLoc, attrs.getList(), AS,
1193 DS.getModulePrivateSpecLoc(),
1194 TParams, Owned, IsDependent, false,
1195 false, clang::TypeResult());
1197 // If ActOnTag said the type was dependent, try again with the
1198 // less common call.
1200 assert(TUK == Sema::TUK_Reference || TUK == Sema::TUK_Friend);
1201 TypeResult = Actions.ActOnDependentTag(getCurScope(), TagType, TUK,
1202 SS, Name, StartLoc, NameLoc);
1206 // If there is a body, parse it and inform the actions module.
1207 if (TUK == Sema::TUK_Definition) {
1208 assert(Tok.is(tok::l_brace) ||
1209 (getLang().CPlusPlus && Tok.is(tok::colon)) ||
1210 isCXX0XFinalKeyword());
1211 if (getLang().CPlusPlus)
1212 ParseCXXMemberSpecification(StartLoc, TagType, TagOrTempResult.get());
1214 ParseStructUnionBody(StartLoc, TagType, TagOrTempResult.get());
1217 const char *PrevSpec = 0;
1220 if (!TypeResult.isInvalid()) {
1221 Result = DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc,
1222 NameLoc.isValid() ? NameLoc : StartLoc,
1223 PrevSpec, DiagID, TypeResult.get());
1224 } else if (!TagOrTempResult.isInvalid()) {
1225 Result = DS.SetTypeSpecType(TagType, StartLoc,
1226 NameLoc.isValid() ? NameLoc : StartLoc,
1227 PrevSpec, DiagID, TagOrTempResult.get(), Owned);
1229 DS.SetTypeSpecError();
1234 Diag(StartLoc, DiagID) << PrevSpec;
1236 // At this point, we've successfully parsed a class-specifier in 'definition'
1237 // form (e.g. "struct foo { int x; }". While we could just return here, we're
1238 // going to look at what comes after it to improve error recovery. If an
1239 // impossible token occurs next, we assume that the programmer forgot a ; at
1240 // the end of the declaration and recover that way.
1242 // This switch enumerates the valid "follow" set for definition.
1243 if (TUK == Sema::TUK_Definition) {
1244 bool ExpectedSemi = true;
1245 switch (Tok.getKind()) {
1247 case tok::semi: // struct foo {...} ;
1248 case tok::star: // struct foo {...} * P;
1249 case tok::amp: // struct foo {...} & R = ...
1250 case tok::identifier: // struct foo {...} V ;
1251 case tok::r_paren: //(struct foo {...} ) {4}
1252 case tok::annot_cxxscope: // struct foo {...} a:: b;
1253 case tok::annot_typename: // struct foo {...} a ::b;
1254 case tok::annot_template_id: // struct foo {...} a<int> ::b;
1255 case tok::l_paren: // struct foo {...} ( x);
1256 case tok::comma: // __builtin_offsetof(struct foo{...} ,
1257 ExpectedSemi = false;
1260 case tok::kw_const: // struct foo {...} const x;
1261 case tok::kw_volatile: // struct foo {...} volatile x;
1262 case tok::kw_restrict: // struct foo {...} restrict x;
1263 case tok::kw_inline: // struct foo {...} inline foo() {};
1264 // Storage-class specifiers
1265 case tok::kw_static: // struct foo {...} static x;
1266 case tok::kw_extern: // struct foo {...} extern x;
1267 case tok::kw_typedef: // struct foo {...} typedef x;
1268 case tok::kw_register: // struct foo {...} register x;
1269 case tok::kw_auto: // struct foo {...} auto x;
1270 case tok::kw_mutable: // struct foo {...} mutable x;
1271 case tok::kw_constexpr: // struct foo {...} constexpr x;
1272 // As shown above, type qualifiers and storage class specifiers absolutely
1273 // can occur after class specifiers according to the grammar. However,
1274 // almost no one actually writes code like this. If we see one of these,
1275 // it is much more likely that someone missed a semi colon and the
1276 // type/storage class specifier we're seeing is part of the *next*
1277 // intended declaration, as in:
1279 // struct foo { ... }
1282 // We'd really like to emit a missing semicolon error instead of emitting
1283 // an error on the 'int' saying that you can't have two type specifiers in
1284 // the same declaration of X. Because of this, we look ahead past this
1285 // token to see if it's a type specifier. If so, we know the code is
1286 // otherwise invalid, so we can produce the expected semi error.
1287 if (!isKnownToBeTypeSpecifier(NextToken()))
1288 ExpectedSemi = false;
1291 case tok::r_brace: // struct bar { struct foo {...} }
1292 // Missing ';' at end of struct is accepted as an extension in C mode.
1293 if (!getLang().CPlusPlus)
1294 ExpectedSemi = false;
1298 // C++ [temp]p3 In a template-declaration which defines a class, no
1299 // declarator is permitted.
1300 if (TemplateInfo.Kind)
1301 ExpectedSemi = true;
1304 ExpectAndConsume(tok::semi, diag::err_expected_semi_after_tagdecl,
1305 TagType == DeclSpec::TST_class ? "class"
1306 : TagType == DeclSpec::TST_struct? "struct" : "union");
1307 // Push this token back into the preprocessor and change our current token
1308 // to ';' so that the rest of the code recovers as though there were an
1309 // ';' after the definition.
1311 Tok.setKind(tok::semi);
1316 /// ParseBaseClause - Parse the base-clause of a C++ class [C++ class.derived].
1318 /// base-clause : [C++ class.derived]
1319 /// ':' base-specifier-list
1320 /// base-specifier-list:
1321 /// base-specifier '...'[opt]
1322 /// base-specifier-list ',' base-specifier '...'[opt]
1323 void Parser::ParseBaseClause(Decl *ClassDecl) {
1324 assert(Tok.is(tok::colon) && "Not a base clause");
1327 // Build up an array of parsed base specifiers.
1328 SmallVector<CXXBaseSpecifier *, 8> BaseInfo;
1331 // Parse a base-specifier.
1332 BaseResult Result = ParseBaseSpecifier(ClassDecl);
1333 if (Result.isInvalid()) {
1334 // Skip the rest of this base specifier, up until the comma or
1336 SkipUntil(tok::comma, tok::l_brace, true, true);
1338 // Add this to our array of base specifiers.
1339 BaseInfo.push_back(Result.get());
1342 // If the next token is a comma, consume it and keep reading
1344 if (Tok.isNot(tok::comma)) break;
1346 // Consume the comma.
1350 // Attach the base specifiers
1351 Actions.ActOnBaseSpecifiers(ClassDecl, BaseInfo.data(), BaseInfo.size());
1354 /// ParseBaseSpecifier - Parse a C++ base-specifier. A base-specifier is
1355 /// one entry in the base class list of a class specifier, for example:
1356 /// class foo : public bar, virtual private baz {
1357 /// 'public bar' and 'virtual private baz' are each base-specifiers.
1359 /// base-specifier: [C++ class.derived]
1360 /// ::[opt] nested-name-specifier[opt] class-name
1361 /// 'virtual' access-specifier[opt] ::[opt] nested-name-specifier[opt]
1363 /// access-specifier 'virtual'[opt] ::[opt] nested-name-specifier[opt]
1365 Parser::BaseResult Parser::ParseBaseSpecifier(Decl *ClassDecl) {
1366 bool IsVirtual = false;
1367 SourceLocation StartLoc = Tok.getLocation();
1369 // Parse the 'virtual' keyword.
1370 if (Tok.is(tok::kw_virtual)) {
1375 // Parse an (optional) access specifier.
1376 AccessSpecifier Access = getAccessSpecifierIfPresent();
1377 if (Access != AS_none)
1380 // Parse the 'virtual' keyword (again!), in case it came after the
1381 // access specifier.
1382 if (Tok.is(tok::kw_virtual)) {
1383 SourceLocation VirtualLoc = ConsumeToken();
1385 // Complain about duplicate 'virtual'
1386 Diag(VirtualLoc, diag::err_dup_virtual)
1387 << FixItHint::CreateRemoval(VirtualLoc);
1393 // Parse optional '::' and optional nested-name-specifier.
1395 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), /*EnteringContext=*/false);
1397 // The location of the base class itself.
1398 SourceLocation BaseLoc = Tok.getLocation();
1400 // Parse the class-name.
1401 SourceLocation EndLocation;
1402 TypeResult BaseType = ParseClassName(EndLocation, SS);
1403 if (BaseType.isInvalid())
1406 // Parse the optional ellipsis (for a pack expansion). The ellipsis is
1407 // actually part of the base-specifier-list grammar productions, but we
1408 // parse it here for convenience.
1409 SourceLocation EllipsisLoc;
1410 if (Tok.is(tok::ellipsis))
1411 EllipsisLoc = ConsumeToken();
1413 // Find the complete source range for the base-specifier.
1414 SourceRange Range(StartLoc, EndLocation);
1416 // Notify semantic analysis that we have parsed a complete
1418 return Actions.ActOnBaseSpecifier(ClassDecl, Range, IsVirtual, Access,
1419 BaseType.get(), BaseLoc, EllipsisLoc);
1422 /// getAccessSpecifierIfPresent - Determine whether the next token is
1423 /// a C++ access-specifier.
1425 /// access-specifier: [C++ class.derived]
1429 AccessSpecifier Parser::getAccessSpecifierIfPresent() const {
1430 switch (Tok.getKind()) {
1431 default: return AS_none;
1432 case tok::kw_private: return AS_private;
1433 case tok::kw_protected: return AS_protected;
1434 case tok::kw_public: return AS_public;
1438 void Parser::HandleMemberFunctionDefaultArgs(Declarator& DeclaratorInfo,
1440 // We just declared a member function. If this member function
1441 // has any default arguments, we'll need to parse them later.
1442 LateParsedMethodDeclaration *LateMethod = 0;
1443 DeclaratorChunk::FunctionTypeInfo &FTI
1444 = DeclaratorInfo.getFunctionTypeInfo();
1445 for (unsigned ParamIdx = 0; ParamIdx < FTI.NumArgs; ++ParamIdx) {
1446 if (LateMethod || FTI.ArgInfo[ParamIdx].DefaultArgTokens) {
1448 // Push this method onto the stack of late-parsed method
1450 LateMethod = new LateParsedMethodDeclaration(this, ThisDecl);
1451 getCurrentClass().LateParsedDeclarations.push_back(LateMethod);
1452 LateMethod->TemplateScope = getCurScope()->isTemplateParamScope();
1454 // Add all of the parameters prior to this one (they don't
1455 // have default arguments).
1456 LateMethod->DefaultArgs.reserve(FTI.NumArgs);
1457 for (unsigned I = 0; I < ParamIdx; ++I)
1458 LateMethod->DefaultArgs.push_back(
1459 LateParsedDefaultArgument(FTI.ArgInfo[I].Param));
1462 // Add this parameter to the list of parameters (it or may
1463 // not have a default argument).
1464 LateMethod->DefaultArgs.push_back(
1465 LateParsedDefaultArgument(FTI.ArgInfo[ParamIdx].Param,
1466 FTI.ArgInfo[ParamIdx].DefaultArgTokens));
1471 /// isCXX0XVirtSpecifier - Determine whether the next token is a C++0x
1477 VirtSpecifiers::Specifier Parser::isCXX0XVirtSpecifier() const {
1478 if (!getLang().CPlusPlus)
1479 return VirtSpecifiers::VS_None;
1481 if (Tok.is(tok::identifier)) {
1482 IdentifierInfo *II = Tok.getIdentifierInfo();
1484 // Initialize the contextual keywords.
1486 Ident_final = &PP.getIdentifierTable().get("final");
1487 Ident_override = &PP.getIdentifierTable().get("override");
1490 if (II == Ident_override)
1491 return VirtSpecifiers::VS_Override;
1493 if (II == Ident_final)
1494 return VirtSpecifiers::VS_Final;
1497 return VirtSpecifiers::VS_None;
1500 /// ParseOptionalCXX0XVirtSpecifierSeq - Parse a virt-specifier-seq.
1502 /// virt-specifier-seq:
1504 /// virt-specifier-seq virt-specifier
1505 void Parser::ParseOptionalCXX0XVirtSpecifierSeq(VirtSpecifiers &VS) {
1507 VirtSpecifiers::Specifier Specifier = isCXX0XVirtSpecifier();
1508 if (Specifier == VirtSpecifiers::VS_None)
1511 // C++ [class.mem]p8:
1512 // A virt-specifier-seq shall contain at most one of each virt-specifier.
1513 const char *PrevSpec = 0;
1514 if (VS.SetSpecifier(Specifier, Tok.getLocation(), PrevSpec))
1515 Diag(Tok.getLocation(), diag::err_duplicate_virt_specifier)
1517 << FixItHint::CreateRemoval(Tok.getLocation());
1519 if (!getLang().CPlusPlus0x)
1520 Diag(Tok.getLocation(), diag::ext_override_control_keyword)
1521 << VirtSpecifiers::getSpecifierName(Specifier);
1526 /// isCXX0XFinalKeyword - Determine whether the next token is a C++0x
1527 /// contextual 'final' keyword.
1528 bool Parser::isCXX0XFinalKeyword() const {
1529 if (!getLang().CPlusPlus)
1532 if (!Tok.is(tok::identifier))
1535 // Initialize the contextual keywords.
1537 Ident_final = &PP.getIdentifierTable().get("final");
1538 Ident_override = &PP.getIdentifierTable().get("override");
1541 return Tok.getIdentifierInfo() == Ident_final;
1544 /// ParseCXXClassMemberDeclaration - Parse a C++ class member declaration.
1546 /// member-declaration:
1547 /// decl-specifier-seq[opt] member-declarator-list[opt] ';'
1548 /// function-definition ';'[opt]
1549 /// ::[opt] nested-name-specifier template[opt] unqualified-id ';'[TODO]
1550 /// using-declaration [TODO]
1551 /// [C++0x] static_assert-declaration
1552 /// template-declaration
1553 /// [GNU] '__extension__' member-declaration
1555 /// member-declarator-list:
1556 /// member-declarator
1557 /// member-declarator-list ',' member-declarator
1559 /// member-declarator:
1560 /// declarator virt-specifier-seq[opt] pure-specifier[opt]
1561 /// declarator constant-initializer[opt]
1562 /// [C++11] declarator brace-or-equal-initializer[opt]
1563 /// identifier[opt] ':' constant-expression
1565 /// virt-specifier-seq:
1567 /// virt-specifier-seq virt-specifier
1576 /// constant-initializer:
1577 /// '=' constant-expression
1579 void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS,
1580 AttributeList *AccessAttrs,
1581 const ParsedTemplateInfo &TemplateInfo,
1582 ParsingDeclRAIIObject *TemplateDiags) {
1583 if (Tok.is(tok::at)) {
1584 if (getLang().ObjC1 && NextToken().isObjCAtKeyword(tok::objc_defs))
1585 Diag(Tok, diag::err_at_defs_cxx);
1587 Diag(Tok, diag::err_at_in_class);
1590 SkipUntil(tok::r_brace);
1594 // Access declarations.
1595 if (!TemplateInfo.Kind &&
1596 (Tok.is(tok::identifier) || Tok.is(tok::coloncolon)) &&
1597 !TryAnnotateCXXScopeToken() &&
1598 Tok.is(tok::annot_cxxscope)) {
1599 bool isAccessDecl = false;
1600 if (NextToken().is(tok::identifier))
1601 isAccessDecl = GetLookAheadToken(2).is(tok::semi);
1603 isAccessDecl = NextToken().is(tok::kw_operator);
1606 // Collect the scope specifier token we annotated earlier.
1608 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false);
1610 // Try to parse an unqualified-id.
1612 if (ParseUnqualifiedId(SS, false, true, true, ParsedType(), Name)) {
1613 SkipUntil(tok::semi);
1617 // TODO: recover from mistakenly-qualified operator declarations.
1618 if (ExpectAndConsume(tok::semi,
1619 diag::err_expected_semi_after,
1620 "access declaration",
1624 Actions.ActOnUsingDeclaration(getCurScope(), AS,
1625 false, SourceLocation(),
1628 /* IsTypeName */ false,
1634 // static_assert-declaration
1635 if (Tok.is(tok::kw_static_assert) || Tok.is(tok::kw__Static_assert)) {
1636 // FIXME: Check for templates
1637 SourceLocation DeclEnd;
1638 ParseStaticAssertDeclaration(DeclEnd);
1642 if (Tok.is(tok::kw_template)) {
1643 assert(!TemplateInfo.TemplateParams &&
1644 "Nested template improperly parsed?");
1645 SourceLocation DeclEnd;
1646 ParseDeclarationStartingWithTemplate(Declarator::MemberContext, DeclEnd,
1651 // Handle: member-declaration ::= '__extension__' member-declaration
1652 if (Tok.is(tok::kw___extension__)) {
1653 // __extension__ silences extension warnings in the subexpression.
1654 ExtensionRAIIObject O(Diags); // Use RAII to do this.
1656 return ParseCXXClassMemberDeclaration(AS, AccessAttrs,
1657 TemplateInfo, TemplateDiags);
1660 // Don't parse FOO:BAR as if it were a typo for FOO::BAR, in this context it
1662 ColonProtectionRAIIObject X(*this);
1664 ParsedAttributesWithRange attrs(AttrFactory);
1665 // Optional C++0x attribute-specifier
1666 MaybeParseCXX0XAttributes(attrs);
1667 MaybeParseMicrosoftAttributes(attrs);
1669 if (Tok.is(tok::kw_using)) {
1670 ProhibitAttributes(attrs);
1673 SourceLocation UsingLoc = ConsumeToken();
1675 if (Tok.is(tok::kw_namespace)) {
1676 Diag(UsingLoc, diag::err_using_namespace_in_class);
1677 SkipUntil(tok::semi, true, true);
1679 SourceLocation DeclEnd;
1680 // Otherwise, it must be a using-declaration or an alias-declaration.
1681 ParseUsingDeclaration(Declarator::MemberContext, TemplateInfo,
1682 UsingLoc, DeclEnd, AS);
1687 // decl-specifier-seq:
1688 // Parse the common declaration-specifiers piece.
1689 ParsingDeclSpec DS(*this, TemplateDiags);
1690 DS.takeAttributesFrom(attrs);
1691 ParseDeclarationSpecifiers(DS, TemplateInfo, AS, DSC_class);
1693 MultiTemplateParamsArg TemplateParams(Actions,
1694 TemplateInfo.TemplateParams? TemplateInfo.TemplateParams->data() : 0,
1695 TemplateInfo.TemplateParams? TemplateInfo.TemplateParams->size() : 0);
1697 if (Tok.is(tok::semi)) {
1700 Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS, DS, TemplateParams);
1701 DS.complete(TheDecl);
1705 ParsingDeclarator DeclaratorInfo(*this, DS, Declarator::MemberContext);
1708 // Hold late-parsed attributes so we can attach a Decl to them later.
1709 LateParsedAttrList LateParsedAttrs;
1711 if (Tok.isNot(tok::colon)) {
1712 // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
1713 ColonProtectionRAIIObject X(*this);
1715 // Parse the first declarator.
1716 ParseDeclarator(DeclaratorInfo);
1717 // Error parsing the declarator?
1718 if (!DeclaratorInfo.hasName()) {
1719 // If so, skip until the semi-colon or a }.
1720 SkipUntil(tok::r_brace, true, true);
1721 if (Tok.is(tok::semi))
1726 ParseOptionalCXX0XVirtSpecifierSeq(VS);
1728 // If attributes exist after the declarator, but before an '{', parse them.
1729 MaybeParseGNUAttributes(DeclaratorInfo, &LateParsedAttrs);
1731 // MSVC permits pure specifier on inline functions declared at class scope.
1732 // Hence check for =0 before checking for function definition.
1734 if (getLang().MicrosoftExt && Tok.is(tok::equal) &&
1735 DeclaratorInfo.isFunctionDeclarator() &&
1736 NextToken().is(tok::numeric_constant)) {
1738 Init = ParseInitializer();
1739 if (Init.isInvalid())
1740 SkipUntil(tok::comma, true, true);
1743 bool IsDefinition = false;
1744 // function-definition:
1746 // In C++11, a non-function declarator followed by an open brace is a
1747 // braced-init-list for an in-class member initialization, not an
1748 // erroneous function definition.
1749 if (Tok.is(tok::l_brace) && !getLang().CPlusPlus0x) {
1750 IsDefinition = true;
1751 } else if (DeclaratorInfo.isFunctionDeclarator()) {
1752 if (Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try)) {
1753 IsDefinition = true;
1754 } else if (Tok.is(tok::equal)) {
1755 const Token &KW = NextToken();
1756 if (KW.is(tok::kw_default) || KW.is(tok::kw_delete))
1757 IsDefinition = true;
1762 if (!DeclaratorInfo.isFunctionDeclarator()) {
1763 Diag(Tok, diag::err_func_def_no_params);
1765 SkipUntil(tok::r_brace, true);
1767 // Consume the optional ';'
1768 if (Tok.is(tok::semi))
1773 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
1774 Diag(Tok, diag::err_function_declared_typedef);
1775 // This recovery skips the entire function body. It would be nice
1776 // to simply call ParseCXXInlineMethodDef() below, however Sema
1777 // assumes the declarator represents a function, not a typedef.
1779 SkipUntil(tok::r_brace, true);
1781 // Consume the optional ';'
1782 if (Tok.is(tok::semi))
1788 ParseCXXInlineMethodDef(AS, AccessAttrs, DeclaratorInfo, TemplateInfo,
1791 for (unsigned i = 0, ni = LateParsedAttrs.size(); i < ni; ++i) {
1792 LateParsedAttrs[i]->setDecl(FunDecl);
1794 LateParsedAttrs.clear();
1796 // Consume the ';' - it's optional unless we have a delete or default
1797 if (Tok.is(tok::semi)) {
1805 // member-declarator-list:
1806 // member-declarator
1807 // member-declarator-list ',' member-declarator
1809 SmallVector<Decl *, 8> DeclsInGroup;
1810 ExprResult BitfieldSize;
1813 // member-declarator:
1814 // declarator pure-specifier[opt]
1815 // declarator brace-or-equal-initializer[opt]
1816 // identifier[opt] ':' constant-expression
1817 if (Tok.is(tok::colon)) {
1819 BitfieldSize = ParseConstantExpression();
1820 if (BitfieldSize.isInvalid())
1821 SkipUntil(tok::comma, true, true);
1824 // If a simple-asm-expr is present, parse it.
1825 if (Tok.is(tok::kw_asm)) {
1827 ExprResult AsmLabel(ParseSimpleAsm(&Loc));
1828 if (AsmLabel.isInvalid())
1829 SkipUntil(tok::comma, true, true);
1831 DeclaratorInfo.setAsmLabel(AsmLabel.release());
1832 DeclaratorInfo.SetRangeEnd(Loc);
1835 // If attributes exist after the declarator, parse them.
1836 MaybeParseGNUAttributes(DeclaratorInfo, &LateParsedAttrs);
1838 // FIXME: When g++ adds support for this, we'll need to check whether it
1839 // goes before or after the GNU attributes and __asm__.
1840 ParseOptionalCXX0XVirtSpecifierSeq(VS);
1842 bool HasInitializer = false;
1843 bool HasDeferredInitializer = false;
1844 if (Tok.is(tok::equal) || Tok.is(tok::l_brace)) {
1845 if (BitfieldSize.get()) {
1846 Diag(Tok, diag::err_bitfield_member_init);
1847 SkipUntil(tok::comma, true, true);
1849 HasInitializer = true;
1850 HasDeferredInitializer = !DeclaratorInfo.isDeclarationOfFunction() &&
1851 DeclaratorInfo.getDeclSpec().getStorageClassSpec()
1852 != DeclSpec::SCS_static &&
1853 DeclaratorInfo.getDeclSpec().getStorageClassSpec()
1854 != DeclSpec::SCS_typedef;
1858 // NOTE: If Sema is the Action module and declarator is an instance field,
1859 // this call will *not* return the created decl; It will return null.
1860 // See Sema::ActOnCXXMemberDeclarator for details.
1863 if (DS.isFriendSpecified()) {
1864 // TODO: handle initializers, bitfields, 'delete'
1865 ThisDecl = Actions.ActOnFriendFunctionDecl(getCurScope(), DeclaratorInfo,
1866 move(TemplateParams));
1868 ThisDecl = Actions.ActOnCXXMemberDeclarator(getCurScope(), AS,
1870 move(TemplateParams),
1871 BitfieldSize.release(),
1872 VS, HasDeferredInitializer);
1874 Actions.ProcessDeclAttributeList(getCurScope(), ThisDecl, AccessAttrs,
1878 // Set the Decl for any late parsed attributes
1879 for (unsigned i = 0, ni = LateParsedAttrs.size(); i < ni; ++i) {
1880 LateParsedAttrs[i]->setDecl(ThisDecl);
1882 LateParsedAttrs.clear();
1884 // Handle the initializer.
1885 if (HasDeferredInitializer) {
1886 // The initializer was deferred; parse it and cache the tokens.
1887 if (!getLang().CPlusPlus0x)
1888 Diag(Tok, diag::warn_nonstatic_member_init_accepted_as_extension);
1890 if (DeclaratorInfo.isArrayOfUnknownBound()) {
1891 // C++0x [dcl.array]p3: An array bound may also be omitted when the
1892 // declarator is followed by an initializer.
1894 // A brace-or-equal-initializer for a member-declarator is not an
1895 // initializer in the gramamr, so this is ill-formed.
1896 Diag(Tok, diag::err_incomplete_array_member_init);
1897 SkipUntil(tok::comma, true, true);
1898 // Avoid later warnings about a class member of incomplete type.
1899 ThisDecl->setInvalidDecl();
1901 ParseCXXNonStaticMemberInitializer(ThisDecl);
1902 } else if (HasInitializer) {
1903 // Normal initializer.
1904 SourceLocation EqualLoc;
1906 = ParseCXXMemberInitializer(DeclaratorInfo.isDeclarationOfFunction(),
1908 if (Init.isInvalid())
1909 SkipUntil(tok::comma, true, true);
1911 Actions.AddInitializerToDecl(ThisDecl, Init.get(), false,
1912 DS.getTypeSpecType() == DeclSpec::TST_auto);
1913 } else if (ThisDecl && DS.getStorageClassSpec() == DeclSpec::SCS_static) {
1915 Actions.ActOnUninitializedDecl(ThisDecl,
1916 DS.getTypeSpecType() == DeclSpec::TST_auto);
1920 Actions.FinalizeDeclaration(ThisDecl);
1921 DeclsInGroup.push_back(ThisDecl);
1924 if (DeclaratorInfo.isFunctionDeclarator() &&
1925 DeclaratorInfo.getDeclSpec().getStorageClassSpec()
1926 != DeclSpec::SCS_typedef) {
1927 HandleMemberFunctionDefaultArgs(DeclaratorInfo, ThisDecl);
1930 DeclaratorInfo.complete(ThisDecl);
1932 // If we don't have a comma, it is either the end of the list (a ';')
1933 // or an error, bail out.
1934 if (Tok.isNot(tok::comma))
1937 // Consume the comma.
1940 // Parse the next declarator.
1941 DeclaratorInfo.clear();
1943 BitfieldSize = true;
1945 // Attributes are only allowed on the second declarator.
1946 MaybeParseGNUAttributes(DeclaratorInfo);
1948 if (Tok.isNot(tok::colon))
1949 ParseDeclarator(DeclaratorInfo);
1952 if (ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list)) {
1953 // Skip to end of block or statement.
1954 SkipUntil(tok::r_brace, true, true);
1955 // If we stopped at a ';', eat it.
1956 if (Tok.is(tok::semi)) ConsumeToken();
1960 Actions.FinalizeDeclaratorGroup(getCurScope(), DS, DeclsInGroup.data(),
1961 DeclsInGroup.size());
1964 /// ParseCXXMemberInitializer - Parse the brace-or-equal-initializer or
1965 /// pure-specifier. Also detect and reject any attempted defaulted/deleted
1966 /// function definition. The location of the '=', if any, will be placed in
1972 /// brace-or-equal-initializer:
1973 /// '=' initializer-expression
1974 /// braced-init-list [TODO]
1976 /// initializer-clause:
1977 /// assignment-expression
1978 /// braced-init-list [TODO]
1980 /// defaulted/deleted function-definition:
1984 /// Prior to C++0x, the assignment-expression in an initializer-clause must
1985 /// be a constant-expression.
1986 ExprResult Parser::ParseCXXMemberInitializer(bool IsFunction,
1987 SourceLocation &EqualLoc) {
1988 assert((Tok.is(tok::equal) || Tok.is(tok::l_brace))
1989 && "Data member initializer not starting with '=' or '{'");
1991 if (Tok.is(tok::equal)) {
1992 EqualLoc = ConsumeToken();
1993 if (Tok.is(tok::kw_delete)) {
1994 // In principle, an initializer of '= delete p;' is legal, but it will
1995 // never type-check. It's better to diagnose it as an ill-formed expression
1996 // than as an ill-formed deleted non-function member.
1997 // An initializer of '= delete p, foo' will never be parsed, because
1998 // a top-level comma always ends the initializer expression.
1999 const Token &Next = NextToken();
2000 if (IsFunction || Next.is(tok::semi) || Next.is(tok::comma) ||
2001 Next.is(tok::eof)) {
2003 Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
2006 Diag(ConsumeToken(), diag::err_deleted_non_function);
2007 return ExprResult();
2009 } else if (Tok.is(tok::kw_default)) {
2011 Diag(Tok, diag::err_default_delete_in_multiple_declaration)
2014 Diag(ConsumeToken(), diag::err_default_special_members);
2015 return ExprResult();
2018 return ParseInitializer();
2020 return ExprError(Diag(Tok, diag::err_generalized_initializer_lists));
2023 /// ParseCXXMemberSpecification - Parse the class definition.
2025 /// member-specification:
2026 /// member-declaration member-specification[opt]
2027 /// access-specifier ':' member-specification[opt]
2029 void Parser::ParseCXXMemberSpecification(SourceLocation RecordLoc,
2030 unsigned TagType, Decl *TagDecl) {
2031 assert((TagType == DeclSpec::TST_struct ||
2032 TagType == DeclSpec::TST_union ||
2033 TagType == DeclSpec::TST_class) && "Invalid TagType!");
2035 PrettyDeclStackTraceEntry CrashInfo(Actions, TagDecl, RecordLoc,
2036 "parsing struct/union/class body");
2038 // Determine whether this is a non-nested class. Note that local
2039 // classes are *not* considered to be nested classes.
2040 bool NonNestedClass = true;
2041 if (!ClassStack.empty()) {
2042 for (const Scope *S = getCurScope(); S; S = S->getParent()) {
2043 if (S->isClassScope()) {
2044 // We're inside a class scope, so this is a nested class.
2045 NonNestedClass = false;
2049 if ((S->getFlags() & Scope::FnScope)) {
2050 // If we're in a function or function template declared in the
2051 // body of a class, then this is a local class rather than a
2053 const Scope *Parent = S->getParent();
2054 if (Parent->isTemplateParamScope())
2055 Parent = Parent->getParent();
2056 if (Parent->isClassScope())
2062 // Enter a scope for the class.
2063 ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope);
2065 // Note that we are parsing a new (potentially-nested) class definition.
2066 ParsingClassDefinition ParsingDef(*this, TagDecl, NonNestedClass);
2069 Actions.ActOnTagStartDefinition(getCurScope(), TagDecl);
2071 SourceLocation FinalLoc;
2073 // Parse the optional 'final' keyword.
2074 if (getLang().CPlusPlus && Tok.is(tok::identifier)) {
2075 IdentifierInfo *II = Tok.getIdentifierInfo();
2077 // Initialize the contextual keywords.
2079 Ident_final = &PP.getIdentifierTable().get("final");
2080 Ident_override = &PP.getIdentifierTable().get("override");
2083 if (II == Ident_final)
2084 FinalLoc = ConsumeToken();
2086 if (!getLang().CPlusPlus0x)
2087 Diag(FinalLoc, diag::ext_override_control_keyword) << "final";
2090 if (Tok.is(tok::colon)) {
2091 ParseBaseClause(TagDecl);
2093 if (!Tok.is(tok::l_brace)) {
2094 Diag(Tok, diag::err_expected_lbrace_after_base_specifiers);
2097 Actions.ActOnTagDefinitionError(getCurScope(), TagDecl);
2102 assert(Tok.is(tok::l_brace));
2103 BalancedDelimiterTracker T(*this, tok::l_brace);
2107 Actions.ActOnStartCXXMemberDeclarations(getCurScope(), TagDecl, FinalLoc,
2108 T.getOpenLocation());
2110 // C++ 11p3: Members of a class defined with the keyword class are private
2111 // by default. Members of a class defined with the keywords struct or union
2112 // are public by default.
2113 AccessSpecifier CurAS;
2114 if (TagType == DeclSpec::TST_class)
2118 ParsedAttributes AccessAttrs(AttrFactory);
2121 // While we still have something to read, read the member-declarations.
2122 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
2123 // Each iteration of this loop reads one member-declaration.
2125 if (getLang().MicrosoftExt && (Tok.is(tok::kw___if_exists) ||
2126 Tok.is(tok::kw___if_not_exists))) {
2127 ParseMicrosoftIfExistsClassDeclaration((DeclSpec::TST)TagType, CurAS);
2131 // Check for extraneous top-level semicolon.
2132 if (Tok.is(tok::semi)) {
2133 Diag(Tok, diag::ext_extra_struct_semi)
2134 << DeclSpec::getSpecifierName((DeclSpec::TST)TagType)
2135 << FixItHint::CreateRemoval(Tok.getLocation());
2140 AccessSpecifier AS = getAccessSpecifierIfPresent();
2141 if (AS != AS_none) {
2142 // Current token is a C++ access specifier.
2144 SourceLocation ASLoc = Tok.getLocation();
2145 unsigned TokLength = Tok.getLength();
2147 AccessAttrs.clear();
2148 MaybeParseGNUAttributes(AccessAttrs);
2150 SourceLocation EndLoc;
2151 if (Tok.is(tok::colon)) {
2152 EndLoc = Tok.getLocation();
2153 if (Actions.ActOnAccessSpecifier(AS, ASLoc, EndLoc,
2154 AccessAttrs.getList())) {
2155 // found another attribute than only annotations
2156 AccessAttrs.clear();
2159 } else if (Tok.is(tok::semi)) {
2160 EndLoc = Tok.getLocation();
2162 Diag(EndLoc, diag::err_expected_colon)
2163 << FixItHint::CreateReplacement(EndLoc, ":");
2165 EndLoc = ASLoc.getLocWithOffset(TokLength);
2166 Diag(EndLoc, diag::err_expected_colon)
2167 << FixItHint::CreateInsertion(EndLoc, ":");
2169 Actions.ActOnAccessSpecifier(AS, ASLoc, EndLoc);
2173 // FIXME: Make sure we don't have a template here.
2175 // Parse all the comma separated declarators.
2176 ParseCXXClassMemberDeclaration(CurAS, AccessAttrs.getList());
2181 SkipUntil(tok::r_brace, false, false);
2184 // If attributes exist after class contents, parse them.
2185 ParsedAttributes attrs(AttrFactory);
2186 MaybeParseGNUAttributes(attrs);
2189 Actions.ActOnFinishCXXMemberSpecification(getCurScope(), RecordLoc, TagDecl,
2190 T.getOpenLocation(),
2191 T.getCloseLocation(),
2194 // C++0x [class.mem]p2: Within the class member-specification, the class is
2195 // regarded as complete within function bodies, default arguments, exception-
2196 // specifications, and brace-or-equal-initializers for non-static data
2197 // members (including such things in nested classes).
2199 // FIXME: Only function bodies and brace-or-equal-initializers are currently
2200 // handled. Fix the others!
2201 if (TagDecl && NonNestedClass) {
2202 // We are not inside a nested class. This class and its nested classes
2203 // are complete and we can parse the delayed portions of method
2204 // declarations and the lexed inline method definitions, along with any
2205 // delayed attributes.
2206 SourceLocation SavedPrevTokLocation = PrevTokLocation;
2207 ParseLexedAttributes(getCurrentClass());
2208 ParseLexedMethodDeclarations(getCurrentClass());
2209 ParseLexedMemberInitializers(getCurrentClass());
2210 ParseLexedMethodDefs(getCurrentClass());
2211 PrevTokLocation = SavedPrevTokLocation;
2215 Actions.ActOnTagFinishDefinition(getCurScope(), TagDecl,
2216 T.getCloseLocation());
2218 // Leave the class scope.
2223 /// ParseConstructorInitializer - Parse a C++ constructor initializer,
2224 /// which explicitly initializes the members or base classes of a
2225 /// class (C++ [class.base.init]). For example, the three initializers
2226 /// after the ':' in the Derived constructor below:
2230 /// class Derived : Base {
2234 /// Derived(float f) : Base(), x(17), f(f) { }
2238 /// [C++] ctor-initializer:
2239 /// ':' mem-initializer-list
2241 /// [C++] mem-initializer-list:
2242 /// mem-initializer ...[opt]
2243 /// mem-initializer ...[opt] , mem-initializer-list
2244 void Parser::ParseConstructorInitializer(Decl *ConstructorDecl) {
2245 assert(Tok.is(tok::colon) && "Constructor initializer always starts with ':'");
2247 // Poison the SEH identifiers so they are flagged as illegal in constructor initializers
2248 PoisonSEHIdentifiersRAIIObject PoisonSEHIdentifiers(*this, true);
2249 SourceLocation ColonLoc = ConsumeToken();
2251 SmallVector<CXXCtorInitializer*, 4> MemInitializers;
2252 bool AnyErrors = false;
2255 if (Tok.is(tok::code_completion)) {
2256 Actions.CodeCompleteConstructorInitializer(ConstructorDecl,
2257 MemInitializers.data(),
2258 MemInitializers.size());
2259 return cutOffParsing();
2261 MemInitResult MemInit = ParseMemInitializer(ConstructorDecl);
2262 if (!MemInit.isInvalid())
2263 MemInitializers.push_back(MemInit.get());
2268 if (Tok.is(tok::comma))
2270 else if (Tok.is(tok::l_brace))
2272 // If the next token looks like a base or member initializer, assume that
2273 // we're just missing a comma.
2274 else if (Tok.is(tok::identifier) || Tok.is(tok::coloncolon)) {
2275 SourceLocation Loc = PP.getLocForEndOfToken(PrevTokLocation);
2276 Diag(Loc, diag::err_ctor_init_missing_comma)
2277 << FixItHint::CreateInsertion(Loc, ", ");
2279 // Skip over garbage, until we get to '{'. Don't eat the '{'.
2280 Diag(Tok.getLocation(), diag::err_expected_lbrace_or_comma);
2281 SkipUntil(tok::l_brace, true, true);
2286 Actions.ActOnMemInitializers(ConstructorDecl, ColonLoc,
2287 MemInitializers.data(), MemInitializers.size(),
2291 /// ParseMemInitializer - Parse a C++ member initializer, which is
2292 /// part of a constructor initializer that explicitly initializes one
2293 /// member or base class (C++ [class.base.init]). See
2294 /// ParseConstructorInitializer for an example.
2296 /// [C++] mem-initializer:
2297 /// mem-initializer-id '(' expression-list[opt] ')'
2298 /// [C++0x] mem-initializer-id braced-init-list
2300 /// [C++] mem-initializer-id:
2301 /// '::'[opt] nested-name-specifier[opt] class-name
2303 Parser::MemInitResult Parser::ParseMemInitializer(Decl *ConstructorDecl) {
2304 // parse '::'[opt] nested-name-specifier[opt]
2306 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false);
2307 ParsedType TemplateTypeTy;
2308 if (Tok.is(tok::annot_template_id)) {
2309 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
2310 if (TemplateId->Kind == TNK_Type_template ||
2311 TemplateId->Kind == TNK_Dependent_template_name) {
2312 AnnotateTemplateIdTokenAsType();
2313 assert(Tok.is(tok::annot_typename) && "template-id -> type failed");
2314 TemplateTypeTy = getTypeAnnotation(Tok);
2317 if (!TemplateTypeTy && Tok.isNot(tok::identifier)) {
2318 Diag(Tok, diag::err_expected_member_or_base_name);
2322 // Get the identifier. This may be a member name or a class name,
2323 // but we'll let the semantic analysis determine which it is.
2324 IdentifierInfo *II = Tok.is(tok::identifier) ? Tok.getIdentifierInfo() : 0;
2325 SourceLocation IdLoc = ConsumeToken();
2328 if (getLang().CPlusPlus0x && Tok.is(tok::l_brace)) {
2329 ExprResult InitList = ParseBraceInitializer();
2330 if (InitList.isInvalid())
2333 SourceLocation EllipsisLoc;
2334 if (Tok.is(tok::ellipsis))
2335 EllipsisLoc = ConsumeToken();
2337 return Actions.ActOnMemInitializer(ConstructorDecl, getCurScope(), SS, II,
2338 TemplateTypeTy, IdLoc, InitList.take(),
2340 } else if(Tok.is(tok::l_paren)) {
2341 BalancedDelimiterTracker T(*this, tok::l_paren);
2344 // Parse the optional expression-list.
2345 ExprVector ArgExprs(Actions);
2346 CommaLocsTy CommaLocs;
2347 if (Tok.isNot(tok::r_paren) && ParseExpressionList(ArgExprs, CommaLocs)) {
2348 SkipUntil(tok::r_paren);
2354 SourceLocation EllipsisLoc;
2355 if (Tok.is(tok::ellipsis))
2356 EllipsisLoc = ConsumeToken();
2358 return Actions.ActOnMemInitializer(ConstructorDecl, getCurScope(), SS, II,
2359 TemplateTypeTy, IdLoc,
2360 T.getOpenLocation(), ArgExprs.take(),
2361 ArgExprs.size(), T.getCloseLocation(),
2365 Diag(Tok, getLang().CPlusPlus0x ? diag::err_expected_lparen_or_lbrace
2366 : diag::err_expected_lparen);
2370 /// \brief Parse a C++ exception-specification if present (C++0x [except.spec]).
2372 /// exception-specification:
2373 /// dynamic-exception-specification
2374 /// noexcept-specification
2376 /// noexcept-specification:
2378 /// 'noexcept' '(' constant-expression ')'
2379 ExceptionSpecificationType
2380 Parser::MaybeParseExceptionSpecification(SourceRange &SpecificationRange,
2381 SmallVectorImpl<ParsedType> &DynamicExceptions,
2382 SmallVectorImpl<SourceRange> &DynamicExceptionRanges,
2383 ExprResult &NoexceptExpr) {
2384 ExceptionSpecificationType Result = EST_None;
2386 // See if there's a dynamic specification.
2387 if (Tok.is(tok::kw_throw)) {
2388 Result = ParseDynamicExceptionSpecification(SpecificationRange,
2390 DynamicExceptionRanges);
2391 assert(DynamicExceptions.size() == DynamicExceptionRanges.size() &&
2392 "Produced different number of exception types and ranges.");
2395 // If there's no noexcept specification, we're done.
2396 if (Tok.isNot(tok::kw_noexcept))
2399 // If we already had a dynamic specification, parse the noexcept for,
2400 // recovery, but emit a diagnostic and don't store the results.
2401 SourceRange NoexceptRange;
2402 ExceptionSpecificationType NoexceptType = EST_None;
2404 SourceLocation KeywordLoc = ConsumeToken();
2405 if (Tok.is(tok::l_paren)) {
2406 // There is an argument.
2407 BalancedDelimiterTracker T(*this, tok::l_paren);
2409 NoexceptType = EST_ComputedNoexcept;
2410 NoexceptExpr = ParseConstantExpression();
2411 // The argument must be contextually convertible to bool. We use
2412 // ActOnBooleanCondition for this purpose.
2413 if (!NoexceptExpr.isInvalid())
2414 NoexceptExpr = Actions.ActOnBooleanCondition(getCurScope(), KeywordLoc,
2415 NoexceptExpr.get());
2417 NoexceptRange = SourceRange(KeywordLoc, T.getCloseLocation());
2419 // There is no argument.
2420 NoexceptType = EST_BasicNoexcept;
2421 NoexceptRange = SourceRange(KeywordLoc, KeywordLoc);
2424 if (Result == EST_None) {
2425 SpecificationRange = NoexceptRange;
2426 Result = NoexceptType;
2428 // If there's a dynamic specification after a noexcept specification,
2429 // parse that and ignore the results.
2430 if (Tok.is(tok::kw_throw)) {
2431 Diag(Tok.getLocation(), diag::err_dynamic_and_noexcept_specification);
2432 ParseDynamicExceptionSpecification(NoexceptRange, DynamicExceptions,
2433 DynamicExceptionRanges);
2436 Diag(Tok.getLocation(), diag::err_dynamic_and_noexcept_specification);
2442 /// ParseDynamicExceptionSpecification - Parse a C++
2443 /// dynamic-exception-specification (C++ [except.spec]).
2445 /// dynamic-exception-specification:
2446 /// 'throw' '(' type-id-list [opt] ')'
2447 /// [MS] 'throw' '(' '...' ')'
2450 /// type-id ... [opt]
2451 /// type-id-list ',' type-id ... [opt]
2453 ExceptionSpecificationType Parser::ParseDynamicExceptionSpecification(
2454 SourceRange &SpecificationRange,
2455 SmallVectorImpl<ParsedType> &Exceptions,
2456 SmallVectorImpl<SourceRange> &Ranges) {
2457 assert(Tok.is(tok::kw_throw) && "expected throw");
2459 SpecificationRange.setBegin(ConsumeToken());
2460 BalancedDelimiterTracker T(*this, tok::l_paren);
2461 if (T.consumeOpen()) {
2462 Diag(Tok, diag::err_expected_lparen_after) << "throw";
2463 SpecificationRange.setEnd(SpecificationRange.getBegin());
2464 return EST_DynamicNone;
2467 // Parse throw(...), a Microsoft extension that means "this function
2468 // can throw anything".
2469 if (Tok.is(tok::ellipsis)) {
2470 SourceLocation EllipsisLoc = ConsumeToken();
2471 if (!getLang().MicrosoftExt)
2472 Diag(EllipsisLoc, diag::ext_ellipsis_exception_spec);
2474 SpecificationRange.setEnd(T.getCloseLocation());
2478 // Parse the sequence of type-ids.
2480 while (Tok.isNot(tok::r_paren)) {
2481 TypeResult Res(ParseTypeName(&Range));
2483 if (Tok.is(tok::ellipsis)) {
2484 // C++0x [temp.variadic]p5:
2485 // - In a dynamic-exception-specification (15.4); the pattern is a
2487 SourceLocation Ellipsis = ConsumeToken();
2488 Range.setEnd(Ellipsis);
2489 if (!Res.isInvalid())
2490 Res = Actions.ActOnPackExpansion(Res.get(), Ellipsis);
2493 if (!Res.isInvalid()) {
2494 Exceptions.push_back(Res.get());
2495 Ranges.push_back(Range);
2498 if (Tok.is(tok::comma))
2505 SpecificationRange.setEnd(T.getCloseLocation());
2506 return Exceptions.empty() ? EST_DynamicNone : EST_Dynamic;
2509 /// ParseTrailingReturnType - Parse a trailing return type on a new-style
2510 /// function declaration.
2511 TypeResult Parser::ParseTrailingReturnType(SourceRange &Range) {
2512 assert(Tok.is(tok::arrow) && "expected arrow");
2516 // FIXME: Need to suppress declarations when parsing this typename.
2517 // Otherwise in this function definition:
2519 // auto f() -> struct X {}
2521 // struct X is parsed as class definition because of the trailing
2523 return ParseTypeName(&Range);
2526 /// \brief We have just started parsing the definition of a new class,
2527 /// so push that class onto our stack of classes that is currently
2529 Sema::ParsingClassState
2530 Parser::PushParsingClass(Decl *ClassDecl, bool NonNestedClass) {
2531 assert((NonNestedClass || !ClassStack.empty()) &&
2532 "Nested class without outer class");
2533 ClassStack.push(new ParsingClass(ClassDecl, NonNestedClass));
2534 return Actions.PushParsingClass();
2537 /// \brief Deallocate the given parsed class and all of its nested
2539 void Parser::DeallocateParsedClasses(Parser::ParsingClass *Class) {
2540 for (unsigned I = 0, N = Class->LateParsedDeclarations.size(); I != N; ++I)
2541 delete Class->LateParsedDeclarations[I];
2545 /// \brief Pop the top class of the stack of classes that are
2546 /// currently being parsed.
2548 /// This routine should be called when we have finished parsing the
2549 /// definition of a class, but have not yet popped the Scope
2550 /// associated with the class's definition.
2552 /// \returns true if the class we've popped is a top-level class,
2553 /// false otherwise.
2554 void Parser::PopParsingClass(Sema::ParsingClassState state) {
2555 assert(!ClassStack.empty() && "Mismatched push/pop for class parsing");
2557 Actions.PopParsingClass(state);
2559 ParsingClass *Victim = ClassStack.top();
2561 if (Victim->TopLevelClass) {
2562 // Deallocate all of the nested classes of this class,
2563 // recursively: we don't need to keep any of this information.
2564 DeallocateParsedClasses(Victim);
2567 assert(!ClassStack.empty() && "Missing top-level class?");
2569 if (Victim->LateParsedDeclarations.empty()) {
2570 // The victim is a nested class, but we will not need to perform
2571 // any processing after the definition of this class since it has
2572 // no members whose handling was delayed. Therefore, we can just
2573 // remove this nested class.
2574 DeallocateParsedClasses(Victim);
2578 // This nested class has some members that will need to be processed
2579 // after the top-level class is completely defined. Therefore, add
2580 // it to the list of nested classes within its parent.
2581 assert(getCurScope()->isClassScope() && "Nested class outside of class scope?");
2582 ClassStack.top()->LateParsedDeclarations.push_back(new LateParsedClass(this, Victim));
2583 Victim->TemplateScope = getCurScope()->getParent()->isTemplateParamScope();
2586 /// ParseCXX0XAttributeSpecifier - Parse a C++0x attribute-specifier. Currently
2587 /// only parses standard attributes.
2589 /// [C++0x] attribute-specifier:
2590 /// '[' '[' attribute-list ']' ']'
2591 /// alignment-specifier
2593 /// [C++0x] attribute-list:
2595 /// attribute-list ',' attribute[opt]
2597 /// [C++0x] attribute:
2598 /// attribute-token attribute-argument-clause[opt]
2600 /// [C++0x] attribute-token:
2602 /// attribute-scoped-token
2604 /// [C++0x] attribute-scoped-token:
2605 /// attribute-namespace '::' identifier
2607 /// [C++0x] attribute-namespace:
2610 /// [C++0x] attribute-argument-clause:
2611 /// '(' balanced-token-seq ')'
2613 /// [C++0x] balanced-token-seq:
2615 /// balanced-token-seq balanced-token
2617 /// [C++0x] balanced-token:
2618 /// '(' balanced-token-seq ')'
2619 /// '[' balanced-token-seq ']'
2620 /// '{' balanced-token-seq '}'
2621 /// any token but '(', ')', '[', ']', '{', or '}'
2622 void Parser::ParseCXX0XAttributeSpecifier(ParsedAttributes &attrs,
2623 SourceLocation *endLoc) {
2624 if (Tok.is(tok::kw_alignas)) {
2625 Diag(Tok.getLocation(), diag::warn_cxx98_compat_alignas);
2626 ParseAlignmentSpecifier(attrs, endLoc);
2630 assert(Tok.is(tok::l_square) && NextToken().is(tok::l_square)
2631 && "Not a C++0x attribute list");
2633 Diag(Tok.getLocation(), diag::warn_cxx98_compat_attribute);
2638 if (Tok.is(tok::comma)) {
2639 Diag(Tok.getLocation(), diag::err_expected_ident);
2643 while (Tok.is(tok::identifier) || Tok.is(tok::comma)) {
2644 // attribute not present
2645 if (Tok.is(tok::comma)) {
2650 IdentifierInfo *ScopeName = 0, *AttrName = Tok.getIdentifierInfo();
2651 SourceLocation ScopeLoc, AttrLoc = ConsumeToken();
2654 if (Tok.is(tok::coloncolon)) {
2657 if (!Tok.is(tok::identifier)) {
2658 Diag(Tok.getLocation(), diag::err_expected_ident);
2659 SkipUntil(tok::r_square, tok::comma, true, true);
2663 ScopeName = AttrName;
2666 AttrName = Tok.getIdentifierInfo();
2667 AttrLoc = ConsumeToken();
2670 bool AttrParsed = false;
2671 // No scoped names are supported; ideally we could put all non-standard
2672 // attributes into namespaces.
2674 switch(AttributeList::getKind(AttrName))
2677 case AttributeList::AT_carries_dependency:
2678 case AttributeList::AT_noreturn: {
2679 if (Tok.is(tok::l_paren)) {
2680 Diag(Tok.getLocation(), diag::err_cxx0x_attribute_forbids_arguments)
2681 << AttrName->getName();
2685 attrs.addNew(AttrName, AttrLoc, 0, AttrLoc, 0,
2686 SourceLocation(), 0, 0, false, true);
2696 // Skip the entire parameter clause, if any
2697 if (!AttrParsed && Tok.is(tok::l_paren)) {
2699 // SkipUntil maintains the balancedness of tokens.
2700 SkipUntil(tok::r_paren, false);
2704 if (ExpectAndConsume(tok::r_square, diag::err_expected_rsquare))
2705 SkipUntil(tok::r_square, false);
2707 *endLoc = Tok.getLocation();
2708 if (ExpectAndConsume(tok::r_square, diag::err_expected_rsquare))
2709 SkipUntil(tok::r_square, false);
2712 /// ParseCXX0XAttributes - Parse a C++0x attribute-specifier-seq.
2714 /// attribute-specifier-seq:
2715 /// attribute-specifier-seq[opt] attribute-specifier
2716 void Parser::ParseCXX0XAttributes(ParsedAttributesWithRange &attrs,
2717 SourceLocation *endLoc) {
2718 SourceLocation StartLoc = Tok.getLocation(), Loc;
2723 ParseCXX0XAttributeSpecifier(attrs, endLoc);
2724 } while (isCXX0XAttributeSpecifier());
2726 attrs.Range = SourceRange(StartLoc, *endLoc);
2729 /// ParseMicrosoftAttributes - Parse a Microsoft attribute [Attr]
2731 /// [MS] ms-attribute:
2732 /// '[' token-seq ']'
2734 /// [MS] ms-attribute-seq:
2735 /// ms-attribute[opt]
2736 /// ms-attribute ms-attribute-seq
2737 void Parser::ParseMicrosoftAttributes(ParsedAttributes &attrs,
2738 SourceLocation *endLoc) {
2739 assert(Tok.is(tok::l_square) && "Not a Microsoft attribute list");
2741 while (Tok.is(tok::l_square)) {
2743 SkipUntil(tok::r_square, true, true);
2744 if (endLoc) *endLoc = Tok.getLocation();
2745 ExpectAndConsume(tok::r_square, diag::err_expected_rsquare);
2749 void Parser::ParseMicrosoftIfExistsClassDeclaration(DeclSpec::TST TagType,
2750 AccessSpecifier& CurAS) {
2752 if (ParseMicrosoftIfExistsCondition(Result))
2755 if (Tok.isNot(tok::l_brace)) {
2756 Diag(Tok, diag::err_expected_lbrace);
2761 // Condition is false skip all inside the {}.
2763 SkipUntil(tok::r_brace, false);
2767 // Condition is true, parse the declaration.
2768 while (Tok.isNot(tok::r_brace)) {
2770 // __if_exists, __if_not_exists can nest.
2771 if ((Tok.is(tok::kw___if_exists) || Tok.is(tok::kw___if_not_exists))) {
2772 ParseMicrosoftIfExistsClassDeclaration((DeclSpec::TST)TagType, CurAS);
2776 // Check for extraneous top-level semicolon.
2777 if (Tok.is(tok::semi)) {
2778 Diag(Tok, diag::ext_extra_struct_semi)
2779 << DeclSpec::getSpecifierName((DeclSpec::TST)TagType)
2780 << FixItHint::CreateRemoval(Tok.getLocation());
2785 AccessSpecifier AS = getAccessSpecifierIfPresent();
2786 if (AS != AS_none) {
2787 // Current token is a C++ access specifier.
2789 SourceLocation ASLoc = Tok.getLocation();
2791 if (Tok.is(tok::colon))
2792 Actions.ActOnAccessSpecifier(AS, ASLoc, Tok.getLocation());
2794 Diag(Tok, diag::err_expected_colon);
2799 // Parse all the comma separated declarators.
2800 ParseCXXClassMemberDeclaration(CurAS, 0);
2803 if (Tok.isNot(tok::r_brace)) {
2804 Diag(Tok, diag::err_expected_rbrace);