ParseDeclCXX.cpp revision 4c97d762d8c5a84f6554e5bfb31d28c90df64158
1//===--- ParseDeclCXX.cpp - C++ Declaration Parsing -----------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the C++ Declaration portions of the Parser interfaces. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Parse/Parser.h" 15#include "clang/Parse/ParseDiagnostic.h" 16#include "clang/Parse/DeclSpec.h" 17#include "clang/Parse/Scope.h" 18#include "AstGuard.h" 19#include "ExtensionRAIIObject.h" 20using namespace clang; 21 22/// ParseNamespace - We know that the current token is a namespace keyword. This 23/// may either be a top level namespace or a block-level namespace alias. 24/// 25/// namespace-definition: [C++ 7.3: basic.namespace] 26/// named-namespace-definition 27/// unnamed-namespace-definition 28/// 29/// unnamed-namespace-definition: 30/// 'namespace' attributes[opt] '{' namespace-body '}' 31/// 32/// named-namespace-definition: 33/// original-namespace-definition 34/// extension-namespace-definition 35/// 36/// original-namespace-definition: 37/// 'namespace' identifier attributes[opt] '{' namespace-body '}' 38/// 39/// extension-namespace-definition: 40/// 'namespace' original-namespace-name '{' namespace-body '}' 41/// 42/// namespace-alias-definition: [C++ 7.3.2: namespace.alias] 43/// 'namespace' identifier '=' qualified-namespace-specifier ';' 44/// 45Parser::DeclPtrTy Parser::ParseNamespace(unsigned Context, 46 SourceLocation &DeclEnd) { 47 assert(Tok.is(tok::kw_namespace) && "Not a namespace!"); 48 SourceLocation NamespaceLoc = ConsumeToken(); // eat the 'namespace'. 49 50 SourceLocation IdentLoc; 51 IdentifierInfo *Ident = 0; 52 53 if (Tok.is(tok::identifier)) { 54 Ident = Tok.getIdentifierInfo(); 55 IdentLoc = ConsumeToken(); // eat the identifier. 56 } 57 58 // Read label attributes, if present. 59 Action::AttrTy *AttrList = 0; 60 if (Tok.is(tok::kw___attribute)) 61 // FIXME: save these somewhere. 62 AttrList = ParseAttributes(); 63 64 if (Tok.is(tok::equal)) 65 // FIXME: Verify no attributes were present. 66 return ParseNamespaceAlias(NamespaceLoc, IdentLoc, Ident, DeclEnd); 67 68 if (Tok.isNot(tok::l_brace)) { 69 Diag(Tok, Ident ? diag::err_expected_lbrace : 70 diag::err_expected_ident_lbrace); 71 return DeclPtrTy(); 72 } 73 74 SourceLocation LBrace = ConsumeBrace(); 75 76 // Enter a scope for the namespace. 77 ParseScope NamespaceScope(this, Scope::DeclScope); 78 79 DeclPtrTy NamespcDecl = 80 Actions.ActOnStartNamespaceDef(CurScope, IdentLoc, Ident, LBrace); 81 82 PrettyStackTraceActionsDecl CrashInfo(NamespcDecl, NamespaceLoc, Actions, 83 PP.getSourceManager(), 84 "parsing namespace"); 85 86 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) 87 ParseExternalDeclaration(); 88 89 // Leave the namespace scope. 90 NamespaceScope.Exit(); 91 92 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBrace); 93 Actions.ActOnFinishNamespaceDef(NamespcDecl, RBraceLoc); 94 95 DeclEnd = RBraceLoc; 96 return NamespcDecl; 97} 98 99/// ParseNamespaceAlias - Parse the part after the '=' in a namespace 100/// alias definition. 101/// 102Parser::DeclPtrTy Parser::ParseNamespaceAlias(SourceLocation NamespaceLoc, 103 SourceLocation AliasLoc, 104 IdentifierInfo *Alias, 105 SourceLocation &DeclEnd) { 106 assert(Tok.is(tok::equal) && "Not equal token"); 107 108 ConsumeToken(); // eat the '='. 109 110 CXXScopeSpec SS; 111 // Parse (optional) nested-name-specifier. 112 ParseOptionalCXXScopeSpecifier(SS); 113 114 if (SS.isInvalid() || Tok.isNot(tok::identifier)) { 115 Diag(Tok, diag::err_expected_namespace_name); 116 // Skip to end of the definition and eat the ';'. 117 SkipUntil(tok::semi); 118 return DeclPtrTy(); 119 } 120 121 // Parse identifier. 122 IdentifierInfo *Ident = Tok.getIdentifierInfo(); 123 SourceLocation IdentLoc = ConsumeToken(); 124 125 // Eat the ';'. 126 DeclEnd = Tok.getLocation(); 127 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, 128 "namespace name", tok::semi); 129 130 return Actions.ActOnNamespaceAliasDef(CurScope, NamespaceLoc, AliasLoc, Alias, 131 SS, IdentLoc, Ident); 132} 133 134/// ParseLinkage - We know that the current token is a string_literal 135/// and just before that, that extern was seen. 136/// 137/// linkage-specification: [C++ 7.5p2: dcl.link] 138/// 'extern' string-literal '{' declaration-seq[opt] '}' 139/// 'extern' string-literal declaration 140/// 141Parser::DeclPtrTy Parser::ParseLinkage(unsigned Context) { 142 assert(Tok.is(tok::string_literal) && "Not a string literal!"); 143 llvm::SmallVector<char, 8> LangBuffer; 144 // LangBuffer is guaranteed to be big enough. 145 LangBuffer.resize(Tok.getLength()); 146 const char *LangBufPtr = &LangBuffer[0]; 147 unsigned StrSize = PP.getSpelling(Tok, LangBufPtr); 148 149 SourceLocation Loc = ConsumeStringToken(); 150 151 ParseScope LinkageScope(this, Scope::DeclScope); 152 DeclPtrTy LinkageSpec 153 = Actions.ActOnStartLinkageSpecification(CurScope, 154 /*FIXME: */SourceLocation(), 155 Loc, LangBufPtr, StrSize, 156 Tok.is(tok::l_brace)? Tok.getLocation() 157 : SourceLocation()); 158 159 if (Tok.isNot(tok::l_brace)) { 160 ParseDeclarationOrFunctionDefinition(); 161 return Actions.ActOnFinishLinkageSpecification(CurScope, LinkageSpec, 162 SourceLocation()); 163 } 164 165 SourceLocation LBrace = ConsumeBrace(); 166 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) { 167 ParseExternalDeclaration(); 168 } 169 170 SourceLocation RBrace = MatchRHSPunctuation(tok::r_brace, LBrace); 171 return Actions.ActOnFinishLinkageSpecification(CurScope, LinkageSpec, RBrace); 172} 173 174/// ParseUsingDirectiveOrDeclaration - Parse C++ using using-declaration or 175/// using-directive. Assumes that current token is 'using'. 176Parser::DeclPtrTy Parser::ParseUsingDirectiveOrDeclaration(unsigned Context, 177 SourceLocation &DeclEnd) { 178 assert(Tok.is(tok::kw_using) && "Not using token"); 179 180 // Eat 'using'. 181 SourceLocation UsingLoc = ConsumeToken(); 182 183 if (Tok.is(tok::kw_namespace)) 184 // Next token after 'using' is 'namespace' so it must be using-directive 185 return ParseUsingDirective(Context, UsingLoc, DeclEnd); 186 187 // Otherwise, it must be using-declaration. 188 return ParseUsingDeclaration(Context, UsingLoc, DeclEnd); 189} 190 191/// ParseUsingDirective - Parse C++ using-directive, assumes 192/// that current token is 'namespace' and 'using' was already parsed. 193/// 194/// using-directive: [C++ 7.3.p4: namespace.udir] 195/// 'using' 'namespace' ::[opt] nested-name-specifier[opt] 196/// namespace-name ; 197/// [GNU] using-directive: 198/// 'using' 'namespace' ::[opt] nested-name-specifier[opt] 199/// namespace-name attributes[opt] ; 200/// 201Parser::DeclPtrTy Parser::ParseUsingDirective(unsigned Context, 202 SourceLocation UsingLoc, 203 SourceLocation &DeclEnd) { 204 assert(Tok.is(tok::kw_namespace) && "Not 'namespace' token"); 205 206 // Eat 'namespace'. 207 SourceLocation NamespcLoc = ConsumeToken(); 208 209 CXXScopeSpec SS; 210 // Parse (optional) nested-name-specifier. 211 ParseOptionalCXXScopeSpecifier(SS); 212 213 AttributeList *AttrList = 0; 214 IdentifierInfo *NamespcName = 0; 215 SourceLocation IdentLoc = SourceLocation(); 216 217 // Parse namespace-name. 218 if (SS.isInvalid() || Tok.isNot(tok::identifier)) { 219 Diag(Tok, diag::err_expected_namespace_name); 220 // If there was invalid namespace name, skip to end of decl, and eat ';'. 221 SkipUntil(tok::semi); 222 // FIXME: Are there cases, when we would like to call ActOnUsingDirective? 223 return DeclPtrTy(); 224 } 225 226 // Parse identifier. 227 NamespcName = Tok.getIdentifierInfo(); 228 IdentLoc = ConsumeToken(); 229 230 // Parse (optional) attributes (most likely GNU strong-using extension). 231 if (Tok.is(tok::kw___attribute)) 232 AttrList = ParseAttributes(); 233 234 // Eat ';'. 235 DeclEnd = Tok.getLocation(); 236 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, 237 AttrList ? "attributes list" : "namespace name", tok::semi); 238 239 return Actions.ActOnUsingDirective(CurScope, UsingLoc, NamespcLoc, SS, 240 IdentLoc, NamespcName, AttrList); 241} 242 243/// ParseUsingDeclaration - Parse C++ using-declaration. Assumes that 244/// 'using' was already seen. 245/// 246/// using-declaration: [C++ 7.3.p3: namespace.udecl] 247/// 'using' 'typename'[opt] ::[opt] nested-name-specifier 248/// unqualified-id [TODO] 249/// 'using' :: unqualified-id [TODO] 250/// 251Parser::DeclPtrTy Parser::ParseUsingDeclaration(unsigned Context, 252 SourceLocation UsingLoc, 253 SourceLocation &DeclEnd) { 254 assert(false && "Not implemented"); 255 // FIXME: Implement parsing. 256 return DeclPtrTy(); 257} 258 259/// ParseStaticAssertDeclaration - Parse C++0x static_assert-declaratoion. 260/// 261/// static_assert-declaration: 262/// static_assert ( constant-expression , string-literal ) ; 263/// 264Parser::DeclPtrTy Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd){ 265 assert(Tok.is(tok::kw_static_assert) && "Not a static_assert declaration"); 266 SourceLocation StaticAssertLoc = ConsumeToken(); 267 268 if (Tok.isNot(tok::l_paren)) { 269 Diag(Tok, diag::err_expected_lparen); 270 return DeclPtrTy(); 271 } 272 273 SourceLocation LParenLoc = ConsumeParen(); 274 275 OwningExprResult AssertExpr(ParseConstantExpression()); 276 if (AssertExpr.isInvalid()) { 277 SkipUntil(tok::semi); 278 return DeclPtrTy(); 279 } 280 281 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "", tok::semi)) 282 return DeclPtrTy(); 283 284 if (Tok.isNot(tok::string_literal)) { 285 Diag(Tok, diag::err_expected_string_literal); 286 SkipUntil(tok::semi); 287 return DeclPtrTy(); 288 } 289 290 OwningExprResult AssertMessage(ParseStringLiteralExpression()); 291 if (AssertMessage.isInvalid()) 292 return DeclPtrTy(); 293 294 MatchRHSPunctuation(tok::r_paren, LParenLoc); 295 296 DeclEnd = Tok.getLocation(); 297 ExpectAndConsume(tok::semi, diag::err_expected_semi_after_static_assert); 298 299 return Actions.ActOnStaticAssertDeclaration(StaticAssertLoc, move(AssertExpr), 300 move(AssertMessage)); 301} 302 303/// ParseClassName - Parse a C++ class-name, which names a class. Note 304/// that we only check that the result names a type; semantic analysis 305/// will need to verify that the type names a class. The result is 306/// either a type or NULL, depending on whether a type name was 307/// found. 308/// 309/// class-name: [C++ 9.1] 310/// identifier 311/// simple-template-id 312/// 313Parser::TypeResult Parser::ParseClassName(SourceLocation &EndLocation, 314 const CXXScopeSpec *SS) { 315 // Check whether we have a template-id that names a type. 316 if (Tok.is(tok::annot_template_id)) { 317 TemplateIdAnnotation *TemplateId 318 = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue()); 319 if (TemplateId->Kind == TNK_Type_template) { 320 AnnotateTemplateIdTokenAsType(SS); 321 322 assert(Tok.is(tok::annot_typename) && "template-id -> type failed"); 323 TypeTy *Type = Tok.getAnnotationValue(); 324 EndLocation = Tok.getAnnotationEndLoc(); 325 ConsumeToken(); 326 327 if (Type) 328 return Type; 329 return true; 330 } 331 332 // Fall through to produce an error below. 333 } 334 335 if (Tok.isNot(tok::identifier)) { 336 Diag(Tok, diag::err_expected_class_name); 337 return true; 338 } 339 340 // We have an identifier; check whether it is actually a type. 341 TypeTy *Type = Actions.getTypeName(*Tok.getIdentifierInfo(), 342 Tok.getLocation(), CurScope, SS); 343 if (!Type) { 344 Diag(Tok, diag::err_expected_class_name); 345 return true; 346 } 347 348 // Consume the identifier. 349 EndLocation = ConsumeToken(); 350 return Type; 351} 352 353/// ParseClassSpecifier - Parse a C++ class-specifier [C++ class] or 354/// elaborated-type-specifier [C++ dcl.type.elab]; we can't tell which 355/// until we reach the start of a definition or see a token that 356/// cannot start a definition. 357/// 358/// class-specifier: [C++ class] 359/// class-head '{' member-specification[opt] '}' 360/// class-head '{' member-specification[opt] '}' attributes[opt] 361/// class-head: 362/// class-key identifier[opt] base-clause[opt] 363/// class-key nested-name-specifier identifier base-clause[opt] 364/// class-key nested-name-specifier[opt] simple-template-id 365/// base-clause[opt] 366/// [GNU] class-key attributes[opt] identifier[opt] base-clause[opt] 367/// [GNU] class-key attributes[opt] nested-name-specifier 368/// identifier base-clause[opt] 369/// [GNU] class-key attributes[opt] nested-name-specifier[opt] 370/// simple-template-id base-clause[opt] 371/// class-key: 372/// 'class' 373/// 'struct' 374/// 'union' 375/// 376/// elaborated-type-specifier: [C++ dcl.type.elab] 377/// class-key ::[opt] nested-name-specifier[opt] identifier 378/// class-key ::[opt] nested-name-specifier[opt] 'template'[opt] 379/// simple-template-id 380/// 381/// Note that the C++ class-specifier and elaborated-type-specifier, 382/// together, subsume the C99 struct-or-union-specifier: 383/// 384/// struct-or-union-specifier: [C99 6.7.2.1] 385/// struct-or-union identifier[opt] '{' struct-contents '}' 386/// struct-or-union identifier 387/// [GNU] struct-or-union attributes[opt] identifier[opt] '{' struct-contents 388/// '}' attributes[opt] 389/// [GNU] struct-or-union attributes[opt] identifier 390/// struct-or-union: 391/// 'struct' 392/// 'union' 393void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind, 394 SourceLocation StartLoc, DeclSpec &DS, 395 TemplateParameterLists *TemplateParams, 396 AccessSpecifier AS) { 397 DeclSpec::TST TagType; 398 if (TagTokKind == tok::kw_struct) 399 TagType = DeclSpec::TST_struct; 400 else if (TagTokKind == tok::kw_class) 401 TagType = DeclSpec::TST_class; 402 else { 403 assert(TagTokKind == tok::kw_union && "Not a class specifier"); 404 TagType = DeclSpec::TST_union; 405 } 406 407 AttributeList *Attr = 0; 408 // If attributes exist after tag, parse them. 409 if (Tok.is(tok::kw___attribute)) 410 Attr = ParseAttributes(); 411 412 // If declspecs exist after tag, parse them. 413 if (Tok.is(tok::kw___declspec) && PP.getLangOptions().Microsoft) 414 FuzzyParseMicrosoftDeclSpec(); 415 416 // Parse the (optional) nested-name-specifier. 417 CXXScopeSpec SS; 418 if (getLang().CPlusPlus && ParseOptionalCXXScopeSpecifier(SS)) 419 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::annot_template_id)) 420 Diag(Tok, diag::err_expected_ident); 421 422 // Parse the (optional) class name or simple-template-id. 423 IdentifierInfo *Name = 0; 424 SourceLocation NameLoc; 425 TemplateIdAnnotation *TemplateId = 0; 426 if (Tok.is(tok::identifier)) { 427 Name = Tok.getIdentifierInfo(); 428 NameLoc = ConsumeToken(); 429 } else if (Tok.is(tok::annot_template_id)) { 430 TemplateId = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue()); 431 NameLoc = ConsumeToken(); 432 433 if (TemplateId->Kind != TNK_Type_template) { 434 // The template-name in the simple-template-id refers to 435 // something other than a class template. Give an appropriate 436 // error message and skip to the ';'. 437 SourceRange Range(NameLoc); 438 if (SS.isNotEmpty()) 439 Range.setBegin(SS.getBeginLoc()); 440 441 Diag(TemplateId->LAngleLoc, diag::err_template_spec_syntax_non_template) 442 << Name << static_cast<int>(TemplateId->Kind) << Range; 443 444 DS.SetTypeSpecError(); 445 SkipUntil(tok::semi, false, true); 446 TemplateId->Destroy(); 447 return; 448 } 449 } 450 451 // There are three options here. If we have 'struct foo;', then 452 // this is a forward declaration. If we have 'struct foo {...' or 453 // 'struct foo :...' then this is a definition. Otherwise we have 454 // something like 'struct foo xyz', a reference. 455 Action::TagKind TK; 456 if (Tok.is(tok::l_brace) || (getLang().CPlusPlus && Tok.is(tok::colon))) 457 TK = Action::TK_Definition; 458 else if (Tok.is(tok::semi)) 459 TK = Action::TK_Declaration; 460 else 461 TK = Action::TK_Reference; 462 463 if (!Name && !TemplateId && TK != Action::TK_Definition) { 464 // We have a declaration or reference to an anonymous class. 465 Diag(StartLoc, diag::err_anon_type_definition) 466 << DeclSpec::getSpecifierName(TagType); 467 468 // Skip the rest of this declarator, up until the comma or semicolon. 469 SkipUntil(tok::comma, true); 470 471 if (TemplateId) 472 TemplateId->Destroy(); 473 return; 474 } 475 476 // Create the tag portion of the class or class template. 477 Action::DeclResult TagOrTempResult; 478 if (TemplateId && TK != Action::TK_Reference) { 479 // Explicit specialization or class template partial 480 // specialization. Let semantic analysis decide. 481 ASTTemplateArgsPtr TemplateArgsPtr(Actions, 482 TemplateId->getTemplateArgs(), 483 TemplateId->getTemplateArgIsType(), 484 TemplateId->NumArgs); 485 TagOrTempResult 486 = Actions.ActOnClassTemplateSpecialization(CurScope, TagType, TK, 487 StartLoc, SS, 488 TemplateTy::make(TemplateId->Template), 489 TemplateId->TemplateNameLoc, 490 TemplateId->LAngleLoc, 491 TemplateArgsPtr, 492 TemplateId->getTemplateArgLocations(), 493 TemplateId->RAngleLoc, 494 Attr, 495 Action::MultiTemplateParamsArg(Actions, 496 TemplateParams? &(*TemplateParams)[0] : 0, 497 TemplateParams? TemplateParams->size() : 0)); 498 TemplateId->Destroy(); 499 } else if (TemplateParams && TK != Action::TK_Reference) 500 TagOrTempResult = Actions.ActOnClassTemplate(CurScope, TagType, TK, 501 StartLoc, SS, Name, NameLoc, 502 Attr, 503 Action::MultiTemplateParamsArg(Actions, 504 &(*TemplateParams)[0], 505 TemplateParams->size()), 506 AS); 507 else 508 TagOrTempResult = Actions.ActOnTag(CurScope, TagType, TK, StartLoc, SS, Name, 509 NameLoc, Attr, AS); 510 511 // Parse the optional base clause (C++ only). 512 if (getLang().CPlusPlus && Tok.is(tok::colon)) 513 ParseBaseClause(TagOrTempResult.get()); 514 515 // If there is a body, parse it and inform the actions module. 516 if (Tok.is(tok::l_brace)) 517 if (getLang().CPlusPlus) 518 ParseCXXMemberSpecification(StartLoc, TagType, TagOrTempResult.get()); 519 else 520 ParseStructUnionBody(StartLoc, TagType, TagOrTempResult.get()); 521 else if (TK == Action::TK_Definition) { 522 // FIXME: Complain that we have a base-specifier list but no 523 // definition. 524 Diag(Tok, diag::err_expected_lbrace); 525 } 526 527 const char *PrevSpec = 0; 528 if (TagOrTempResult.isInvalid()) 529 DS.SetTypeSpecError(); 530 else if (DS.SetTypeSpecType(TagType, StartLoc, PrevSpec, 531 TagOrTempResult.get().getAs<void>())) 532 Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec; 533} 534 535/// ParseBaseClause - Parse the base-clause of a C++ class [C++ class.derived]. 536/// 537/// base-clause : [C++ class.derived] 538/// ':' base-specifier-list 539/// base-specifier-list: 540/// base-specifier '...'[opt] 541/// base-specifier-list ',' base-specifier '...'[opt] 542void Parser::ParseBaseClause(DeclPtrTy ClassDecl) { 543 assert(Tok.is(tok::colon) && "Not a base clause"); 544 ConsumeToken(); 545 546 // Build up an array of parsed base specifiers. 547 llvm::SmallVector<BaseTy *, 8> BaseInfo; 548 549 while (true) { 550 // Parse a base-specifier. 551 BaseResult Result = ParseBaseSpecifier(ClassDecl); 552 if (Result.isInvalid()) { 553 // Skip the rest of this base specifier, up until the comma or 554 // opening brace. 555 SkipUntil(tok::comma, tok::l_brace, true, true); 556 } else { 557 // Add this to our array of base specifiers. 558 BaseInfo.push_back(Result.get()); 559 } 560 561 // If the next token is a comma, consume it and keep reading 562 // base-specifiers. 563 if (Tok.isNot(tok::comma)) break; 564 565 // Consume the comma. 566 ConsumeToken(); 567 } 568 569 // Attach the base specifiers 570 Actions.ActOnBaseSpecifiers(ClassDecl, &BaseInfo[0], BaseInfo.size()); 571} 572 573/// ParseBaseSpecifier - Parse a C++ base-specifier. A base-specifier is 574/// one entry in the base class list of a class specifier, for example: 575/// class foo : public bar, virtual private baz { 576/// 'public bar' and 'virtual private baz' are each base-specifiers. 577/// 578/// base-specifier: [C++ class.derived] 579/// ::[opt] nested-name-specifier[opt] class-name 580/// 'virtual' access-specifier[opt] ::[opt] nested-name-specifier[opt] 581/// class-name 582/// access-specifier 'virtual'[opt] ::[opt] nested-name-specifier[opt] 583/// class-name 584Parser::BaseResult Parser::ParseBaseSpecifier(DeclPtrTy ClassDecl) { 585 bool IsVirtual = false; 586 SourceLocation StartLoc = Tok.getLocation(); 587 588 // Parse the 'virtual' keyword. 589 if (Tok.is(tok::kw_virtual)) { 590 ConsumeToken(); 591 IsVirtual = true; 592 } 593 594 // Parse an (optional) access specifier. 595 AccessSpecifier Access = getAccessSpecifierIfPresent(); 596 if (Access) 597 ConsumeToken(); 598 599 // Parse the 'virtual' keyword (again!), in case it came after the 600 // access specifier. 601 if (Tok.is(tok::kw_virtual)) { 602 SourceLocation VirtualLoc = ConsumeToken(); 603 if (IsVirtual) { 604 // Complain about duplicate 'virtual' 605 Diag(VirtualLoc, diag::err_dup_virtual) 606 << CodeModificationHint::CreateRemoval(SourceRange(VirtualLoc)); 607 } 608 609 IsVirtual = true; 610 } 611 612 // Parse optional '::' and optional nested-name-specifier. 613 CXXScopeSpec SS; 614 ParseOptionalCXXScopeSpecifier(SS); 615 616 // The location of the base class itself. 617 SourceLocation BaseLoc = Tok.getLocation(); 618 619 // Parse the class-name. 620 SourceLocation EndLocation; 621 TypeResult BaseType = ParseClassName(EndLocation, &SS); 622 if (BaseType.isInvalid()) 623 return true; 624 625 // Find the complete source range for the base-specifier. 626 SourceRange Range(StartLoc, EndLocation); 627 628 // Notify semantic analysis that we have parsed a complete 629 // base-specifier. 630 return Actions.ActOnBaseSpecifier(ClassDecl, Range, IsVirtual, Access, 631 BaseType.get(), BaseLoc); 632} 633 634/// getAccessSpecifierIfPresent - Determine whether the next token is 635/// a C++ access-specifier. 636/// 637/// access-specifier: [C++ class.derived] 638/// 'private' 639/// 'protected' 640/// 'public' 641AccessSpecifier Parser::getAccessSpecifierIfPresent() const 642{ 643 switch (Tok.getKind()) { 644 default: return AS_none; 645 case tok::kw_private: return AS_private; 646 case tok::kw_protected: return AS_protected; 647 case tok::kw_public: return AS_public; 648 } 649} 650 651/// ParseCXXClassMemberDeclaration - Parse a C++ class member declaration. 652/// 653/// member-declaration: 654/// decl-specifier-seq[opt] member-declarator-list[opt] ';' 655/// function-definition ';'[opt] 656/// ::[opt] nested-name-specifier template[opt] unqualified-id ';'[TODO] 657/// using-declaration [TODO] 658/// [C++0x] static_assert-declaration 659/// template-declaration 660/// [GNU] '__extension__' member-declaration 661/// 662/// member-declarator-list: 663/// member-declarator 664/// member-declarator-list ',' member-declarator 665/// 666/// member-declarator: 667/// declarator pure-specifier[opt] 668/// declarator constant-initializer[opt] 669/// identifier[opt] ':' constant-expression 670/// 671/// pure-specifier: 672/// '= 0' 673/// 674/// constant-initializer: 675/// '=' constant-expression 676/// 677void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS) { 678 // static_assert-declaration 679 if (Tok.is(tok::kw_static_assert)) { 680 SourceLocation DeclEnd; 681 ParseStaticAssertDeclaration(DeclEnd); 682 return; 683 } 684 685 if (Tok.is(tok::kw_template)) { 686 SourceLocation DeclEnd; 687 ParseTemplateDeclarationOrSpecialization(Declarator::MemberContext, DeclEnd, 688 AS); 689 return; 690 } 691 692 // Handle: member-declaration ::= '__extension__' member-declaration 693 if (Tok.is(tok::kw___extension__)) { 694 // __extension__ silences extension warnings in the subexpression. 695 ExtensionRAIIObject O(Diags); // Use RAII to do this. 696 ConsumeToken(); 697 return ParseCXXClassMemberDeclaration(AS); 698 } 699 700 SourceLocation DSStart = Tok.getLocation(); 701 // decl-specifier-seq: 702 // Parse the common declaration-specifiers piece. 703 DeclSpec DS; 704 ParseDeclarationSpecifiers(DS, 0, AS); 705 706 if (Tok.is(tok::semi)) { 707 ConsumeToken(); 708 // C++ 9.2p7: The member-declarator-list can be omitted only after a 709 // class-specifier or an enum-specifier or in a friend declaration. 710 // FIXME: Friend declarations. 711 switch (DS.getTypeSpecType()) { 712 case DeclSpec::TST_struct: 713 case DeclSpec::TST_union: 714 case DeclSpec::TST_class: 715 case DeclSpec::TST_enum: 716 Actions.ParsedFreeStandingDeclSpec(CurScope, DS); 717 return; 718 default: 719 Diag(DSStart, diag::err_no_declarators); 720 return; 721 } 722 } 723 724 Declarator DeclaratorInfo(DS, Declarator::MemberContext); 725 726 if (Tok.isNot(tok::colon)) { 727 // Parse the first declarator. 728 ParseDeclarator(DeclaratorInfo); 729 // Error parsing the declarator? 730 if (!DeclaratorInfo.hasName()) { 731 // If so, skip until the semi-colon or a }. 732 SkipUntil(tok::r_brace, true); 733 if (Tok.is(tok::semi)) 734 ConsumeToken(); 735 return; 736 } 737 738 // function-definition: 739 if (Tok.is(tok::l_brace) 740 || (DeclaratorInfo.isFunctionDeclarator() && Tok.is(tok::colon))) { 741 if (!DeclaratorInfo.isFunctionDeclarator()) { 742 Diag(Tok, diag::err_func_def_no_params); 743 ConsumeBrace(); 744 SkipUntil(tok::r_brace, true); 745 return; 746 } 747 748 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) { 749 Diag(Tok, diag::err_function_declared_typedef); 750 // This recovery skips the entire function body. It would be nice 751 // to simply call ParseCXXInlineMethodDef() below, however Sema 752 // assumes the declarator represents a function, not a typedef. 753 ConsumeBrace(); 754 SkipUntil(tok::r_brace, true); 755 return; 756 } 757 758 ParseCXXInlineMethodDef(AS, DeclaratorInfo); 759 return; 760 } 761 } 762 763 // member-declarator-list: 764 // member-declarator 765 // member-declarator-list ',' member-declarator 766 767 llvm::SmallVector<DeclPtrTy, 8> DeclsInGroup; 768 OwningExprResult BitfieldSize(Actions); 769 OwningExprResult Init(Actions); 770 bool Deleted = false; 771 772 while (1) { 773 774 // member-declarator: 775 // declarator pure-specifier[opt] 776 // declarator constant-initializer[opt] 777 // identifier[opt] ':' constant-expression 778 779 if (Tok.is(tok::colon)) { 780 ConsumeToken(); 781 BitfieldSize = ParseConstantExpression(); 782 if (BitfieldSize.isInvalid()) 783 SkipUntil(tok::comma, true, true); 784 } 785 786 // pure-specifier: 787 // '= 0' 788 // 789 // constant-initializer: 790 // '=' constant-expression 791 // 792 // defaulted/deleted function-definition: 793 // '=' 'default' [TODO] 794 // '=' 'delete' 795 796 if (Tok.is(tok::equal)) { 797 ConsumeToken(); 798 if (getLang().CPlusPlus0x && Tok.is(tok::kw_delete)) { 799 ConsumeToken(); 800 Deleted = true; 801 } else { 802 Init = ParseInitializer(); 803 if (Init.isInvalid()) 804 SkipUntil(tok::comma, true, true); 805 } 806 } 807 808 // If attributes exist after the declarator, parse them. 809 if (Tok.is(tok::kw___attribute)) { 810 SourceLocation Loc; 811 AttributeList *AttrList = ParseAttributes(&Loc); 812 DeclaratorInfo.AddAttributes(AttrList, Loc); 813 } 814 815 // NOTE: If Sema is the Action module and declarator is an instance field, 816 // this call will *not* return the created decl; It will return null. 817 // See Sema::ActOnCXXMemberDeclarator for details. 818 DeclPtrTy ThisDecl = Actions.ActOnCXXMemberDeclarator(CurScope, AS, 819 DeclaratorInfo, 820 BitfieldSize.release(), 821 Init.release(), 822 Deleted); 823 if (ThisDecl) 824 DeclsInGroup.push_back(ThisDecl); 825 826 if (DeclaratorInfo.isFunctionDeclarator() && 827 DeclaratorInfo.getDeclSpec().getStorageClassSpec() 828 != DeclSpec::SCS_typedef) { 829 // We just declared a member function. If this member function 830 // has any default arguments, we'll need to parse them later. 831 LateParsedMethodDeclaration *LateMethod = 0; 832 DeclaratorChunk::FunctionTypeInfo &FTI 833 = DeclaratorInfo.getTypeObject(0).Fun; 834 for (unsigned ParamIdx = 0; ParamIdx < FTI.NumArgs; ++ParamIdx) { 835 if (LateMethod || FTI.ArgInfo[ParamIdx].DefaultArgTokens) { 836 if (!LateMethod) { 837 // Push this method onto the stack of late-parsed method 838 // declarations. 839 getCurTopClassStack().MethodDecls.push_back( 840 LateParsedMethodDeclaration(ThisDecl)); 841 LateMethod = &getCurTopClassStack().MethodDecls.back(); 842 843 // Add all of the parameters prior to this one (they don't 844 // have default arguments). 845 LateMethod->DefaultArgs.reserve(FTI.NumArgs); 846 for (unsigned I = 0; I < ParamIdx; ++I) 847 LateMethod->DefaultArgs.push_back( 848 LateParsedDefaultArgument(FTI.ArgInfo[ParamIdx].Param)); 849 } 850 851 // Add this parameter to the list of parameters (it or may 852 // not have a default argument). 853 LateMethod->DefaultArgs.push_back( 854 LateParsedDefaultArgument(FTI.ArgInfo[ParamIdx].Param, 855 FTI.ArgInfo[ParamIdx].DefaultArgTokens)); 856 } 857 } 858 } 859 860 // If we don't have a comma, it is either the end of the list (a ';') 861 // or an error, bail out. 862 if (Tok.isNot(tok::comma)) 863 break; 864 865 // Consume the comma. 866 ConsumeToken(); 867 868 // Parse the next declarator. 869 DeclaratorInfo.clear(); 870 BitfieldSize = 0; 871 Init = 0; 872 Deleted = false; 873 874 // Attributes are only allowed on the second declarator. 875 if (Tok.is(tok::kw___attribute)) { 876 SourceLocation Loc; 877 AttributeList *AttrList = ParseAttributes(&Loc); 878 DeclaratorInfo.AddAttributes(AttrList, Loc); 879 } 880 881 if (Tok.isNot(tok::colon)) 882 ParseDeclarator(DeclaratorInfo); 883 } 884 885 if (Tok.is(tok::semi)) { 886 ConsumeToken(); 887 Actions.FinalizeDeclaratorGroup(CurScope, &DeclsInGroup[0], 888 DeclsInGroup.size()); 889 return; 890 } 891 892 Diag(Tok, diag::err_expected_semi_decl_list); 893 // Skip to end of block or statement 894 SkipUntil(tok::r_brace, true, true); 895 if (Tok.is(tok::semi)) 896 ConsumeToken(); 897 return; 898} 899 900/// ParseCXXMemberSpecification - Parse the class definition. 901/// 902/// member-specification: 903/// member-declaration member-specification[opt] 904/// access-specifier ':' member-specification[opt] 905/// 906void Parser::ParseCXXMemberSpecification(SourceLocation RecordLoc, 907 unsigned TagType, DeclPtrTy TagDecl) { 908 assert((TagType == DeclSpec::TST_struct || 909 TagType == DeclSpec::TST_union || 910 TagType == DeclSpec::TST_class) && "Invalid TagType!"); 911 912 PrettyStackTraceActionsDecl CrashInfo(TagDecl, RecordLoc, Actions, 913 PP.getSourceManager(), 914 "parsing struct/union/class body"); 915 916 SourceLocation LBraceLoc = ConsumeBrace(); 917 918 if (!CurScope->isClassScope() && // Not about to define a nested class. 919 CurScope->isInCXXInlineMethodScope()) { 920 // We will define a local class of an inline method. 921 // Push a new LexedMethodsForTopClass for its inline methods. 922 PushTopClassStack(); 923 } 924 925 // Enter a scope for the class. 926 ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope); 927 928 if (TagDecl) 929 Actions.ActOnTagStartDefinition(CurScope, TagDecl); 930 else { 931 SkipUntil(tok::r_brace, false, false); 932 return; 933 } 934 935 // C++ 11p3: Members of a class defined with the keyword class are private 936 // by default. Members of a class defined with the keywords struct or union 937 // are public by default. 938 AccessSpecifier CurAS; 939 if (TagType == DeclSpec::TST_class) 940 CurAS = AS_private; 941 else 942 CurAS = AS_public; 943 944 // While we still have something to read, read the member-declarations. 945 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) { 946 // Each iteration of this loop reads one member-declaration. 947 948 // Check for extraneous top-level semicolon. 949 if (Tok.is(tok::semi)) { 950 Diag(Tok, diag::ext_extra_struct_semi); 951 ConsumeToken(); 952 continue; 953 } 954 955 AccessSpecifier AS = getAccessSpecifierIfPresent(); 956 if (AS != AS_none) { 957 // Current token is a C++ access specifier. 958 CurAS = AS; 959 ConsumeToken(); 960 ExpectAndConsume(tok::colon, diag::err_expected_colon); 961 continue; 962 } 963 964 // Parse all the comma separated declarators. 965 ParseCXXClassMemberDeclaration(CurAS); 966 } 967 968 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc); 969 970 AttributeList *AttrList = 0; 971 // If attributes exist after class contents, parse them. 972 if (Tok.is(tok::kw___attribute)) 973 AttrList = ParseAttributes(); // FIXME: where should I put them? 974 975 Actions.ActOnFinishCXXMemberSpecification(CurScope, RecordLoc, TagDecl, 976 LBraceLoc, RBraceLoc); 977 978 // C++ 9.2p2: Within the class member-specification, the class is regarded as 979 // complete within function bodies, default arguments, 980 // exception-specifications, and constructor ctor-initializers (including 981 // such things in nested classes). 982 // 983 // FIXME: Only function bodies and constructor ctor-initializers are 984 // parsed correctly, fix the rest. 985 if (!CurScope->getParent()->isClassScope()) { 986 // We are not inside a nested class. This class and its nested classes 987 // are complete and we can parse the delayed portions of method 988 // declarations and the lexed inline method definitions. 989 ParseLexedMethodDeclarations(); 990 ParseLexedMethodDefs(); 991 992 // For a local class of inline method, pop the LexedMethodsForTopClass that 993 // was previously pushed. 994 995 assert((CurScope->isInCXXInlineMethodScope() || 996 TopClassStacks.size() == 1) && 997 "MethodLexers not getting popped properly!"); 998 if (CurScope->isInCXXInlineMethodScope()) 999 PopTopClassStack(); 1000 } 1001 1002 // Leave the class scope. 1003 ClassScope.Exit(); 1004 1005 Actions.ActOnTagFinishDefinition(CurScope, TagDecl); 1006} 1007 1008/// ParseConstructorInitializer - Parse a C++ constructor initializer, 1009/// which explicitly initializes the members or base classes of a 1010/// class (C++ [class.base.init]). For example, the three initializers 1011/// after the ':' in the Derived constructor below: 1012/// 1013/// @code 1014/// class Base { }; 1015/// class Derived : Base { 1016/// int x; 1017/// float f; 1018/// public: 1019/// Derived(float f) : Base(), x(17), f(f) { } 1020/// }; 1021/// @endcode 1022/// 1023/// [C++] ctor-initializer: 1024/// ':' mem-initializer-list 1025/// 1026/// [C++] mem-initializer-list: 1027/// mem-initializer 1028/// mem-initializer , mem-initializer-list 1029void Parser::ParseConstructorInitializer(DeclPtrTy ConstructorDecl) { 1030 assert(Tok.is(tok::colon) && "Constructor initializer always starts with ':'"); 1031 1032 SourceLocation ColonLoc = ConsumeToken(); 1033 1034 llvm::SmallVector<MemInitTy*, 4> MemInitializers; 1035 1036 do { 1037 MemInitResult MemInit = ParseMemInitializer(ConstructorDecl); 1038 if (!MemInit.isInvalid()) 1039 MemInitializers.push_back(MemInit.get()); 1040 1041 if (Tok.is(tok::comma)) 1042 ConsumeToken(); 1043 else if (Tok.is(tok::l_brace)) 1044 break; 1045 else { 1046 // Skip over garbage, until we get to '{'. Don't eat the '{'. 1047 SkipUntil(tok::l_brace, true, true); 1048 break; 1049 } 1050 } while (true); 1051 1052 Actions.ActOnMemInitializers(ConstructorDecl, ColonLoc, 1053 &MemInitializers[0], MemInitializers.size()); 1054} 1055 1056/// ParseMemInitializer - Parse a C++ member initializer, which is 1057/// part of a constructor initializer that explicitly initializes one 1058/// member or base class (C++ [class.base.init]). See 1059/// ParseConstructorInitializer for an example. 1060/// 1061/// [C++] mem-initializer: 1062/// mem-initializer-id '(' expression-list[opt] ')' 1063/// 1064/// [C++] mem-initializer-id: 1065/// '::'[opt] nested-name-specifier[opt] class-name 1066/// identifier 1067Parser::MemInitResult Parser::ParseMemInitializer(DeclPtrTy ConstructorDecl) { 1068 // FIXME: parse '::'[opt] nested-name-specifier[opt] 1069 1070 if (Tok.isNot(tok::identifier)) { 1071 Diag(Tok, diag::err_expected_member_or_base_name); 1072 return true; 1073 } 1074 1075 // Get the identifier. This may be a member name or a class name, 1076 // but we'll let the semantic analysis determine which it is. 1077 IdentifierInfo *II = Tok.getIdentifierInfo(); 1078 SourceLocation IdLoc = ConsumeToken(); 1079 1080 // Parse the '('. 1081 if (Tok.isNot(tok::l_paren)) { 1082 Diag(Tok, diag::err_expected_lparen); 1083 return true; 1084 } 1085 SourceLocation LParenLoc = ConsumeParen(); 1086 1087 // Parse the optional expression-list. 1088 ExprVector ArgExprs(Actions); 1089 CommaLocsTy CommaLocs; 1090 if (Tok.isNot(tok::r_paren) && ParseExpressionList(ArgExprs, CommaLocs)) { 1091 SkipUntil(tok::r_paren); 1092 return true; 1093 } 1094 1095 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 1096 1097 return Actions.ActOnMemInitializer(ConstructorDecl, CurScope, II, IdLoc, 1098 LParenLoc, ArgExprs.take(), 1099 ArgExprs.size(), &CommaLocs[0], RParenLoc); 1100} 1101 1102/// ParseExceptionSpecification - Parse a C++ exception-specification 1103/// (C++ [except.spec]). 1104/// 1105/// exception-specification: 1106/// 'throw' '(' type-id-list [opt] ')' 1107/// [MS] 'throw' '(' '...' ')' 1108/// 1109/// type-id-list: 1110/// type-id 1111/// type-id-list ',' type-id 1112/// 1113bool Parser::ParseExceptionSpecification(SourceLocation &EndLoc) { 1114 assert(Tok.is(tok::kw_throw) && "expected throw"); 1115 1116 SourceLocation ThrowLoc = ConsumeToken(); 1117 1118 if (!Tok.is(tok::l_paren)) { 1119 return Diag(Tok, diag::err_expected_lparen_after) << "throw"; 1120 } 1121 SourceLocation LParenLoc = ConsumeParen(); 1122 1123 // Parse throw(...), a Microsoft extension that means "this function 1124 // can throw anything". 1125 if (Tok.is(tok::ellipsis)) { 1126 SourceLocation EllipsisLoc = ConsumeToken(); 1127 if (!getLang().Microsoft) 1128 Diag(EllipsisLoc, diag::ext_ellipsis_exception_spec); 1129 EndLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 1130 return false; 1131 } 1132 1133 // Parse the sequence of type-ids. 1134 while (Tok.isNot(tok::r_paren)) { 1135 ParseTypeName(); 1136 if (Tok.is(tok::comma)) 1137 ConsumeToken(); 1138 else 1139 break; 1140 } 1141 1142 EndLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 1143 return false; 1144} 1145