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