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