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