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