ParseDeclCXX.cpp revision 374929f7e88f6c7a96382b3eb4201b721c418372
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/Parse/DeclSpec.h" 18#include "clang/Parse/Scope.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 Token attrTok; 54 55 if (Tok.is(tok::identifier)) { 56 Ident = Tok.getIdentifierInfo(); 57 IdentLoc = ConsumeToken(); // eat the identifier. 58 } 59 60 // Read label attributes, if present. 61 Action::AttrTy *AttrList = 0; 62 if (Tok.is(tok::kw___attribute)) { 63 attrTok = Tok; 64 65 // FIXME: save these somewhere. 66 AttrList = ParseAttributes(); 67 } 68 69 if (Tok.is(tok::equal)) { 70 if (AttrList) 71 Diag(attrTok, diag::err_unexpected_namespace_attributes_alias); 72 73 return ParseNamespaceAlias(NamespaceLoc, IdentLoc, Ident, DeclEnd); 74 } 75 76 if (Tok.isNot(tok::l_brace)) { 77 Diag(Tok, Ident ? diag::err_expected_lbrace : 78 diag::err_expected_ident_lbrace); 79 return DeclPtrTy(); 80 } 81 82 SourceLocation LBrace = ConsumeBrace(); 83 84 // Enter a scope for the namespace. 85 ParseScope NamespaceScope(this, Scope::DeclScope); 86 87 DeclPtrTy NamespcDecl = 88 Actions.ActOnStartNamespaceDef(CurScope, IdentLoc, Ident, LBrace); 89 90 PrettyStackTraceActionsDecl CrashInfo(NamespcDecl, NamespaceLoc, Actions, 91 PP.getSourceManager(), 92 "parsing namespace"); 93 94 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) 95 ParseExternalDeclaration(); 96 97 // Leave the namespace scope. 98 NamespaceScope.Exit(); 99 100 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBrace); 101 Actions.ActOnFinishNamespaceDef(NamespcDecl, RBraceLoc); 102 103 DeclEnd = RBraceLoc; 104 return NamespcDecl; 105} 106 107/// ParseNamespaceAlias - Parse the part after the '=' in a namespace 108/// alias definition. 109/// 110Parser::DeclPtrTy Parser::ParseNamespaceAlias(SourceLocation NamespaceLoc, 111 SourceLocation AliasLoc, 112 IdentifierInfo *Alias, 113 SourceLocation &DeclEnd) { 114 assert(Tok.is(tok::equal) && "Not equal token"); 115 116 ConsumeToken(); // eat the '='. 117 118 CXXScopeSpec SS; 119 // Parse (optional) nested-name-specifier. 120 ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/0, false); 121 122 if (SS.isInvalid() || Tok.isNot(tok::identifier)) { 123 Diag(Tok, diag::err_expected_namespace_name); 124 // Skip to end of the definition and eat the ';'. 125 SkipUntil(tok::semi); 126 return DeclPtrTy(); 127 } 128 129 // Parse identifier. 130 IdentifierInfo *Ident = Tok.getIdentifierInfo(); 131 SourceLocation IdentLoc = ConsumeToken(); 132 133 // Eat the ';'. 134 DeclEnd = Tok.getLocation(); 135 ExpectAndConsume(tok::semi, diag::err_expected_semi_after_namespace_name, 136 "", tok::semi); 137 138 return Actions.ActOnNamespaceAliasDef(CurScope, NamespaceLoc, AliasLoc, Alias, 139 SS, IdentLoc, Ident); 140} 141 142/// ParseLinkage - We know that the current token is a string_literal 143/// and just before that, that extern was seen. 144/// 145/// linkage-specification: [C++ 7.5p2: dcl.link] 146/// 'extern' string-literal '{' declaration-seq[opt] '}' 147/// 'extern' string-literal declaration 148/// 149Parser::DeclPtrTy Parser::ParseLinkage(unsigned Context) { 150 assert(Tok.is(tok::string_literal) && "Not a string literal!"); 151 llvm::SmallVector<char, 8> LangBuffer; 152 // LangBuffer is guaranteed to be big enough. 153 LangBuffer.resize(Tok.getLength()); 154 const char *LangBufPtr = &LangBuffer[0]; 155 unsigned StrSize = PP.getSpelling(Tok, LangBufPtr); 156 157 SourceLocation Loc = ConsumeStringToken(); 158 159 ParseScope LinkageScope(this, Scope::DeclScope); 160 DeclPtrTy LinkageSpec 161 = Actions.ActOnStartLinkageSpecification(CurScope, 162 /*FIXME: */SourceLocation(), 163 Loc, LangBufPtr, StrSize, 164 Tok.is(tok::l_brace)? Tok.getLocation() 165 : SourceLocation()); 166 167 if (Tok.isNot(tok::l_brace)) { 168 ParseDeclarationOrFunctionDefinition(); 169 return Actions.ActOnFinishLinkageSpecification(CurScope, LinkageSpec, 170 SourceLocation()); 171 } 172 173 SourceLocation LBrace = ConsumeBrace(); 174 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) { 175 ParseExternalDeclaration(); 176 } 177 178 SourceLocation RBrace = MatchRHSPunctuation(tok::r_brace, LBrace); 179 return Actions.ActOnFinishLinkageSpecification(CurScope, LinkageSpec, RBrace); 180} 181 182/// ParseUsingDirectiveOrDeclaration - Parse C++ using using-declaration or 183/// using-directive. Assumes that current token is 'using'. 184Parser::DeclPtrTy Parser::ParseUsingDirectiveOrDeclaration(unsigned Context, 185 SourceLocation &DeclEnd) { 186 assert(Tok.is(tok::kw_using) && "Not using token"); 187 188 // Eat 'using'. 189 SourceLocation UsingLoc = ConsumeToken(); 190 191 if (Tok.is(tok::kw_namespace)) 192 // Next token after 'using' is 'namespace' so it must be using-directive 193 return ParseUsingDirective(Context, UsingLoc, DeclEnd); 194 195 // Otherwise, it must be using-declaration. 196 return ParseUsingDeclaration(Context, UsingLoc, DeclEnd); 197} 198 199/// ParseUsingDirective - Parse C++ using-directive, assumes 200/// that current token is 'namespace' and 'using' was already parsed. 201/// 202/// using-directive: [C++ 7.3.p4: namespace.udir] 203/// 'using' 'namespace' ::[opt] nested-name-specifier[opt] 204/// namespace-name ; 205/// [GNU] using-directive: 206/// 'using' 'namespace' ::[opt] nested-name-specifier[opt] 207/// namespace-name attributes[opt] ; 208/// 209Parser::DeclPtrTy Parser::ParseUsingDirective(unsigned Context, 210 SourceLocation UsingLoc, 211 SourceLocation &DeclEnd) { 212 assert(Tok.is(tok::kw_namespace) && "Not 'namespace' token"); 213 214 // Eat 'namespace'. 215 SourceLocation NamespcLoc = ConsumeToken(); 216 217 CXXScopeSpec SS; 218 // Parse (optional) nested-name-specifier. 219 ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/0, false); 220 221 AttributeList *AttrList = 0; 222 IdentifierInfo *NamespcName = 0; 223 SourceLocation IdentLoc = SourceLocation(); 224 225 // Parse namespace-name. 226 if (SS.isInvalid() || Tok.isNot(tok::identifier)) { 227 Diag(Tok, diag::err_expected_namespace_name); 228 // If there was invalid namespace name, skip to end of decl, and eat ';'. 229 SkipUntil(tok::semi); 230 // FIXME: Are there cases, when we would like to call ActOnUsingDirective? 231 return DeclPtrTy(); 232 } 233 234 // Parse identifier. 235 NamespcName = Tok.getIdentifierInfo(); 236 IdentLoc = ConsumeToken(); 237 238 // Parse (optional) attributes (most likely GNU strong-using extension). 239 if (Tok.is(tok::kw___attribute)) 240 AttrList = ParseAttributes(); 241 242 // Eat ';'. 243 DeclEnd = Tok.getLocation(); 244 ExpectAndConsume(tok::semi, 245 AttrList ? diag::err_expected_semi_after_attribute_list : 246 diag::err_expected_semi_after_namespace_name, "", tok::semi); 247 248 return Actions.ActOnUsingDirective(CurScope, UsingLoc, NamespcLoc, SS, 249 IdentLoc, NamespcName, AttrList); 250} 251 252/// ParseUsingDeclaration - Parse C++ using-declaration. Assumes that 253/// 'using' was already seen. 254/// 255/// using-declaration: [C++ 7.3.p3: namespace.udecl] 256/// 'using' 'typename'[opt] ::[opt] nested-name-specifier 257/// unqualified-id 258/// 'using' :: unqualified-id 259/// 260Parser::DeclPtrTy Parser::ParseUsingDeclaration(unsigned Context, 261 SourceLocation UsingLoc, 262 SourceLocation &DeclEnd, 263 AccessSpecifier AS) { 264 CXXScopeSpec SS; 265 bool IsTypeName; 266 267 // Ignore optional 'typename'. 268 if (Tok.is(tok::kw_typename)) { 269 ConsumeToken(); 270 IsTypeName = true; 271 } 272 else 273 IsTypeName = false; 274 275 // Parse nested-name-specifier. 276 ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/0, false); 277 278 AttributeList *AttrList = 0; 279 280 // Check nested-name specifier. 281 if (SS.isInvalid()) { 282 SkipUntil(tok::semi); 283 return DeclPtrTy(); 284 } 285 if (Tok.is(tok::annot_template_id)) { 286 // C++0x N2914 [namespace.udecl]p5: 287 // A using-declaration shall not name a template-id. 288 Diag(Tok, diag::err_using_decl_can_not_refer_to_template_spec); 289 SkipUntil(tok::semi); 290 return DeclPtrTy(); 291 } 292 293 IdentifierInfo *TargetName = 0; 294 OverloadedOperatorKind Op = OO_None; 295 SourceLocation IdentLoc; 296 297 if (Tok.is(tok::kw_operator)) { 298 IdentLoc = Tok.getLocation(); 299 300 Op = TryParseOperatorFunctionId(); 301 if (!Op) { 302 // If there was an invalid operator, skip to end of decl, and eat ';'. 303 SkipUntil(tok::semi); 304 return DeclPtrTy(); 305 } 306 } else if (Tok.is(tok::identifier)) { 307 // Parse identifier. 308 TargetName = Tok.getIdentifierInfo(); 309 IdentLoc = ConsumeToken(); 310 } else { 311 // FIXME: Use a better diagnostic here. 312 Diag(Tok, diag::err_expected_ident_in_using); 313 314 // If there was invalid identifier, skip to end of decl, and eat ';'. 315 SkipUntil(tok::semi); 316 return DeclPtrTy(); 317 } 318 319 // Parse (optional) attributes (most likely GNU strong-using extension). 320 if (Tok.is(tok::kw___attribute)) 321 AttrList = ParseAttributes(); 322 323 // Eat ';'. 324 DeclEnd = Tok.getLocation(); 325 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, 326 AttrList ? "attributes list" : "namespace name", tok::semi); 327 328 return Actions.ActOnUsingDeclaration(CurScope, AS, UsingLoc, SS, 329 IdentLoc, TargetName, Op, 330 AttrList, IsTypeName); 331} 332 333/// ParseStaticAssertDeclaration - Parse C++0x static_assert-declaratoion. 334/// 335/// static_assert-declaration: 336/// static_assert ( constant-expression , string-literal ) ; 337/// 338Parser::DeclPtrTy Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd){ 339 assert(Tok.is(tok::kw_static_assert) && "Not a static_assert declaration"); 340 SourceLocation StaticAssertLoc = ConsumeToken(); 341 342 if (Tok.isNot(tok::l_paren)) { 343 Diag(Tok, diag::err_expected_lparen); 344 return DeclPtrTy(); 345 } 346 347 SourceLocation LParenLoc = ConsumeParen(); 348 349 OwningExprResult AssertExpr(ParseConstantExpression()); 350 if (AssertExpr.isInvalid()) { 351 SkipUntil(tok::semi); 352 return DeclPtrTy(); 353 } 354 355 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "", tok::semi)) 356 return DeclPtrTy(); 357 358 if (Tok.isNot(tok::string_literal)) { 359 Diag(Tok, diag::err_expected_string_literal); 360 SkipUntil(tok::semi); 361 return DeclPtrTy(); 362 } 363 364 OwningExprResult AssertMessage(ParseStringLiteralExpression()); 365 if (AssertMessage.isInvalid()) 366 return DeclPtrTy(); 367 368 MatchRHSPunctuation(tok::r_paren, LParenLoc); 369 370 DeclEnd = Tok.getLocation(); 371 ExpectAndConsume(tok::semi, diag::err_expected_semi_after_static_assert); 372 373 return Actions.ActOnStaticAssertDeclaration(StaticAssertLoc, move(AssertExpr), 374 move(AssertMessage)); 375} 376 377/// ParseDecltypeSpecifier - Parse a C++0x decltype specifier. 378/// 379/// 'decltype' ( expression ) 380/// 381void Parser::ParseDecltypeSpecifier(DeclSpec &DS) { 382 assert(Tok.is(tok::kw_decltype) && "Not a decltype specifier"); 383 384 SourceLocation StartLoc = ConsumeToken(); 385 SourceLocation LParenLoc = Tok.getLocation(); 386 387 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, 388 "decltype")) { 389 SkipUntil(tok::r_paren); 390 return; 391 } 392 393 // Parse the expression 394 395 // C++0x [dcl.type.simple]p4: 396 // The operand of the decltype specifier is an unevaluated operand. 397 EnterExpressionEvaluationContext Unevaluated(Actions, 398 Action::Unevaluated); 399 OwningExprResult Result = ParseExpression(); 400 if (Result.isInvalid()) { 401 SkipUntil(tok::r_paren); 402 return; 403 } 404 405 // Match the ')' 406 SourceLocation RParenLoc; 407 if (Tok.is(tok::r_paren)) 408 RParenLoc = ConsumeParen(); 409 else 410 MatchRHSPunctuation(tok::r_paren, LParenLoc); 411 412 if (RParenLoc.isInvalid()) 413 return; 414 415 const char *PrevSpec = 0; 416 unsigned DiagID; 417 // Check for duplicate type specifiers (e.g. "int decltype(a)"). 418 if (DS.SetTypeSpecType(DeclSpec::TST_decltype, StartLoc, PrevSpec, 419 DiagID, Result.release())) 420 Diag(StartLoc, DiagID) << PrevSpec; 421} 422 423/// ParseClassName - Parse a C++ class-name, which names a class. Note 424/// that we only check that the result names a type; semantic analysis 425/// will need to verify that the type names a class. The result is 426/// either a type or NULL, depending on whether a type name was 427/// found. 428/// 429/// class-name: [C++ 9.1] 430/// identifier 431/// simple-template-id 432/// 433Parser::TypeResult Parser::ParseClassName(SourceLocation &EndLocation, 434 const CXXScopeSpec *SS, 435 bool DestrExpected) { 436 // Check whether we have a template-id that names a type. 437 if (Tok.is(tok::annot_template_id)) { 438 TemplateIdAnnotation *TemplateId 439 = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue()); 440 if (TemplateId->Kind == TNK_Type_template) { 441 AnnotateTemplateIdTokenAsType(SS); 442 443 assert(Tok.is(tok::annot_typename) && "template-id -> type failed"); 444 TypeTy *Type = Tok.getAnnotationValue(); 445 EndLocation = Tok.getAnnotationEndLoc(); 446 ConsumeToken(); 447 448 if (Type) 449 return Type; 450 return true; 451 } 452 453 // Fall through to produce an error below. 454 } 455 456 if (Tok.isNot(tok::identifier)) { 457 Diag(Tok, diag::err_expected_class_name); 458 return true; 459 } 460 461 // We have an identifier; check whether it is actually a type. 462 TypeTy *Type = Actions.getTypeName(*Tok.getIdentifierInfo(), 463 Tok.getLocation(), CurScope, SS, 464 true); 465 if (!Type) { 466 Diag(Tok, DestrExpected ? diag::err_destructor_class_name 467 : diag::err_expected_class_name); 468 return true; 469 } 470 471 // Consume the identifier. 472 EndLocation = ConsumeToken(); 473 return Type; 474} 475 476/// ParseClassSpecifier - Parse a C++ class-specifier [C++ class] or 477/// elaborated-type-specifier [C++ dcl.type.elab]; we can't tell which 478/// until we reach the start of a definition or see a token that 479/// cannot start a definition. 480/// 481/// class-specifier: [C++ class] 482/// class-head '{' member-specification[opt] '}' 483/// class-head '{' member-specification[opt] '}' attributes[opt] 484/// class-head: 485/// class-key identifier[opt] base-clause[opt] 486/// class-key nested-name-specifier identifier base-clause[opt] 487/// class-key nested-name-specifier[opt] simple-template-id 488/// base-clause[opt] 489/// [GNU] class-key attributes[opt] identifier[opt] base-clause[opt] 490/// [GNU] class-key attributes[opt] nested-name-specifier 491/// identifier base-clause[opt] 492/// [GNU] class-key attributes[opt] nested-name-specifier[opt] 493/// simple-template-id base-clause[opt] 494/// class-key: 495/// 'class' 496/// 'struct' 497/// 'union' 498/// 499/// elaborated-type-specifier: [C++ dcl.type.elab] 500/// class-key ::[opt] nested-name-specifier[opt] identifier 501/// class-key ::[opt] nested-name-specifier[opt] 'template'[opt] 502/// simple-template-id 503/// 504/// Note that the C++ class-specifier and elaborated-type-specifier, 505/// together, subsume the C99 struct-or-union-specifier: 506/// 507/// struct-or-union-specifier: [C99 6.7.2.1] 508/// struct-or-union identifier[opt] '{' struct-contents '}' 509/// struct-or-union identifier 510/// [GNU] struct-or-union attributes[opt] identifier[opt] '{' struct-contents 511/// '}' attributes[opt] 512/// [GNU] struct-or-union attributes[opt] identifier 513/// struct-or-union: 514/// 'struct' 515/// 'union' 516void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind, 517 SourceLocation StartLoc, DeclSpec &DS, 518 const ParsedTemplateInfo &TemplateInfo, 519 AccessSpecifier AS) { 520 DeclSpec::TST TagType; 521 if (TagTokKind == tok::kw_struct) 522 TagType = DeclSpec::TST_struct; 523 else if (TagTokKind == tok::kw_class) 524 TagType = DeclSpec::TST_class; 525 else { 526 assert(TagTokKind == tok::kw_union && "Not a class specifier"); 527 TagType = DeclSpec::TST_union; 528 } 529 530 if (Tok.is(tok::code_completion)) { 531 // Code completion for a struct, class, or union name. 532 Actions.CodeCompleteTag(CurScope, TagType); 533 ConsumeToken(); 534 } 535 536 AttributeList *Attr = 0; 537 // If attributes exist after tag, parse them. 538 if (Tok.is(tok::kw___attribute)) 539 Attr = ParseAttributes(); 540 541 // If declspecs exist after tag, parse them. 542 if (Tok.is(tok::kw___declspec)) 543 Attr = ParseMicrosoftDeclSpec(Attr); 544 545 if (TagType == DeclSpec::TST_struct && Tok.is(tok::kw___is_pod)) { 546 // GNU libstdc++ 4.2 uses __is_pod as the name of a struct template, but 547 // __is_pod is a keyword in GCC >= 4.3. Therefore, when we see the 548 // token sequence "struct __is_pod", make __is_pod into a normal 549 // identifier rather than a keyword, to allow libstdc++ 4.2 to work 550 // properly. 551 Tok.getIdentifierInfo()->setTokenID(tok::identifier); 552 Tok.setKind(tok::identifier); 553 } 554 555 if (TagType == DeclSpec::TST_struct && Tok.is(tok::kw___is_empty)) { 556 // GNU libstdc++ 4.2 uses __is_empty as the name of a struct template, but 557 // __is_empty is a keyword in GCC >= 4.3. Therefore, when we see the 558 // token sequence "struct __is_empty", make __is_empty into a normal 559 // identifier rather than a keyword, to allow libstdc++ 4.2 to work 560 // properly. 561 Tok.getIdentifierInfo()->setTokenID(tok::identifier); 562 Tok.setKind(tok::identifier); 563 } 564 565 // Parse the (optional) nested-name-specifier. 566 CXXScopeSpec SS; 567 if (getLang().CPlusPlus && 568 ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/0, true)) 569 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::annot_template_id)) 570 Diag(Tok, diag::err_expected_ident); 571 572 // Parse the (optional) class name or simple-template-id. 573 IdentifierInfo *Name = 0; 574 SourceLocation NameLoc; 575 TemplateIdAnnotation *TemplateId = 0; 576 if (Tok.is(tok::identifier)) { 577 Name = Tok.getIdentifierInfo(); 578 NameLoc = ConsumeToken(); 579 } else if (Tok.is(tok::annot_template_id)) { 580 TemplateId = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue()); 581 NameLoc = ConsumeToken(); 582 583 if (TemplateId->Kind != TNK_Type_template) { 584 // The template-name in the simple-template-id refers to 585 // something other than a class template. Give an appropriate 586 // error message and skip to the ';'. 587 SourceRange Range(NameLoc); 588 if (SS.isNotEmpty()) 589 Range.setBegin(SS.getBeginLoc()); 590 591 Diag(TemplateId->LAngleLoc, diag::err_template_spec_syntax_non_template) 592 << Name << static_cast<int>(TemplateId->Kind) << Range; 593 594 DS.SetTypeSpecError(); 595 SkipUntil(tok::semi, false, true); 596 TemplateId->Destroy(); 597 return; 598 } 599 } 600 601 // There are four options here. If we have 'struct foo;', then this 602 // is either a forward declaration or a friend declaration, which 603 // have to be treated differently. If we have 'struct foo {...' or 604 // 'struct foo :...' then this is a definition. Otherwise we have 605 // something like 'struct foo xyz', a reference. 606 Action::TagUseKind TUK; 607 if (Tok.is(tok::l_brace) || (getLang().CPlusPlus && Tok.is(tok::colon))) 608 TUK = Action::TUK_Definition; 609 else if (Tok.is(tok::semi)) 610 TUK = DS.isFriendSpecified() ? Action::TUK_Friend : Action::TUK_Declaration; 611 else 612 TUK = Action::TUK_Reference; 613 614 if (!Name && !TemplateId && TUK != Action::TUK_Definition) { 615 // We have a declaration or reference to an anonymous class. 616 Diag(StartLoc, diag::err_anon_type_definition) 617 << DeclSpec::getSpecifierName(TagType); 618 619 // Skip the rest of this declarator, up until the comma or semicolon. 620 SkipUntil(tok::comma, true); 621 622 if (TemplateId) 623 TemplateId->Destroy(); 624 return; 625 } 626 627 // Create the tag portion of the class or class template. 628 Action::DeclResult TagOrTempResult = true; // invalid 629 Action::TypeResult TypeResult = true; // invalid 630 TemplateParameterLists *TemplateParams = TemplateInfo.TemplateParams; 631 632 // FIXME: When TUK == TUK_Reference and we have a template-id, we need 633 // to turn that template-id into a type. 634 635 bool Owned = false; 636 if (TemplateId) { 637 // Explicit specialization, class template partial specialization, 638 // or explicit instantiation. 639 ASTTemplateArgsPtr TemplateArgsPtr(Actions, 640 TemplateId->getTemplateArgs(), 641 TemplateId->getTemplateArgIsType(), 642 TemplateId->NumArgs); 643 if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation && 644 TUK == Action::TUK_Declaration) { 645 // This is an explicit instantiation of a class template. 646 TagOrTempResult 647 = Actions.ActOnExplicitInstantiation(CurScope, 648 TemplateInfo.ExternLoc, 649 TemplateInfo.TemplateLoc, 650 TagType, 651 StartLoc, 652 SS, 653 TemplateTy::make(TemplateId->Template), 654 TemplateId->TemplateNameLoc, 655 TemplateId->LAngleLoc, 656 TemplateArgsPtr, 657 TemplateId->getTemplateArgLocations(), 658 TemplateId->RAngleLoc, 659 Attr); 660 } else if (TUK == Action::TUK_Reference || TUK == Action::TUK_Friend) { 661 TypeResult 662 = Actions.ActOnTemplateIdType(TemplateTy::make(TemplateId->Template), 663 TemplateId->TemplateNameLoc, 664 TemplateId->LAngleLoc, 665 TemplateArgsPtr, 666 TemplateId->getTemplateArgLocations(), 667 TemplateId->RAngleLoc); 668 669 TypeResult = Actions.ActOnTagTemplateIdType(TypeResult, TUK, 670 TagType, StartLoc); 671 } else { 672 // This is an explicit specialization or a class template 673 // partial specialization. 674 TemplateParameterLists FakedParamLists; 675 676 if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) { 677 // This looks like an explicit instantiation, because we have 678 // something like 679 // 680 // template class Foo<X> 681 // 682 // but it actually has a definition. Most likely, this was 683 // meant to be an explicit specialization, but the user forgot 684 // the '<>' after 'template'. 685 assert(TUK == Action::TUK_Definition && "Expected a definition here"); 686 687 SourceLocation LAngleLoc 688 = PP.getLocForEndOfToken(TemplateInfo.TemplateLoc); 689 Diag(TemplateId->TemplateNameLoc, 690 diag::err_explicit_instantiation_with_definition) 691 << SourceRange(TemplateInfo.TemplateLoc) 692 << CodeModificationHint::CreateInsertion(LAngleLoc, "<>"); 693 694 // Create a fake template parameter list that contains only 695 // "template<>", so that we treat this construct as a class 696 // template specialization. 697 FakedParamLists.push_back( 698 Actions.ActOnTemplateParameterList(0, SourceLocation(), 699 TemplateInfo.TemplateLoc, 700 LAngleLoc, 701 0, 0, 702 LAngleLoc)); 703 TemplateParams = &FakedParamLists; 704 } 705 706 // Build the class template specialization. 707 TagOrTempResult 708 = Actions.ActOnClassTemplateSpecialization(CurScope, TagType, TUK, 709 StartLoc, SS, 710 TemplateTy::make(TemplateId->Template), 711 TemplateId->TemplateNameLoc, 712 TemplateId->LAngleLoc, 713 TemplateArgsPtr, 714 TemplateId->getTemplateArgLocations(), 715 TemplateId->RAngleLoc, 716 Attr, 717 Action::MultiTemplateParamsArg(Actions, 718 TemplateParams? &(*TemplateParams)[0] : 0, 719 TemplateParams? TemplateParams->size() : 0)); 720 } 721 TemplateId->Destroy(); 722 } else if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation && 723 TUK == Action::TUK_Declaration) { 724 // Explicit instantiation of a member of a class template 725 // specialization, e.g., 726 // 727 // template struct Outer<int>::Inner; 728 // 729 TagOrTempResult 730 = Actions.ActOnExplicitInstantiation(CurScope, 731 TemplateInfo.ExternLoc, 732 TemplateInfo.TemplateLoc, 733 TagType, StartLoc, SS, Name, 734 NameLoc, Attr); 735 } else { 736 if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation && 737 TUK == Action::TUK_Definition) { 738 // FIXME: Diagnose this particular error. 739 } 740 741 bool IsDependent = false; 742 743 // Declaration or definition of a class type 744 TagOrTempResult = Actions.ActOnTag(CurScope, TagType, TUK, StartLoc, SS, 745 Name, NameLoc, Attr, AS, 746 Action::MultiTemplateParamsArg(Actions, 747 TemplateParams? &(*TemplateParams)[0] : 0, 748 TemplateParams? TemplateParams->size() : 0), 749 Owned, IsDependent); 750 751 // If ActOnTag said the type was dependent, try again with the 752 // less common call. 753 if (IsDependent) 754 TypeResult = Actions.ActOnDependentTag(CurScope, TagType, TUK, 755 SS, Name, StartLoc, NameLoc); 756 } 757 758 // Parse the optional base clause (C++ only). 759 if (getLang().CPlusPlus && Tok.is(tok::colon)) 760 ParseBaseClause(TagOrTempResult.get()); 761 762 // If there is a body, parse it and inform the actions module. 763 if (Tok.is(tok::l_brace)) 764 if (getLang().CPlusPlus) 765 ParseCXXMemberSpecification(StartLoc, TagType, TagOrTempResult.get()); 766 else 767 ParseStructUnionBody(StartLoc, TagType, TagOrTempResult.get()); 768 else if (TUK == Action::TUK_Definition) { 769 // FIXME: Complain that we have a base-specifier list but no 770 // definition. 771 Diag(Tok, diag::err_expected_lbrace); 772 } 773 774 void *Result; 775 if (!TypeResult.isInvalid()) { 776 TagType = DeclSpec::TST_typename; 777 Result = TypeResult.get(); 778 Owned = false; 779 } else if (!TagOrTempResult.isInvalid()) { 780 Result = TagOrTempResult.get().getAs<void>(); 781 } else { 782 DS.SetTypeSpecError(); 783 return; 784 } 785 786 const char *PrevSpec = 0; 787 unsigned DiagID; 788 789 if (DS.SetTypeSpecType(TagType, StartLoc, PrevSpec, DiagID, 790 Result, Owned)) 791 Diag(StartLoc, DiagID) << PrevSpec; 792} 793 794/// ParseBaseClause - Parse the base-clause of a C++ class [C++ class.derived]. 795/// 796/// base-clause : [C++ class.derived] 797/// ':' base-specifier-list 798/// base-specifier-list: 799/// base-specifier '...'[opt] 800/// base-specifier-list ',' base-specifier '...'[opt] 801void Parser::ParseBaseClause(DeclPtrTy ClassDecl) { 802 assert(Tok.is(tok::colon) && "Not a base clause"); 803 ConsumeToken(); 804 805 // Build up an array of parsed base specifiers. 806 llvm::SmallVector<BaseTy *, 8> BaseInfo; 807 808 while (true) { 809 // Parse a base-specifier. 810 BaseResult Result = ParseBaseSpecifier(ClassDecl); 811 if (Result.isInvalid()) { 812 // Skip the rest of this base specifier, up until the comma or 813 // opening brace. 814 SkipUntil(tok::comma, tok::l_brace, true, true); 815 } else { 816 // Add this to our array of base specifiers. 817 BaseInfo.push_back(Result.get()); 818 } 819 820 // If the next token is a comma, consume it and keep reading 821 // base-specifiers. 822 if (Tok.isNot(tok::comma)) break; 823 824 // Consume the comma. 825 ConsumeToken(); 826 } 827 828 // Attach the base specifiers 829 Actions.ActOnBaseSpecifiers(ClassDecl, BaseInfo.data(), BaseInfo.size()); 830} 831 832/// ParseBaseSpecifier - Parse a C++ base-specifier. A base-specifier is 833/// one entry in the base class list of a class specifier, for example: 834/// class foo : public bar, virtual private baz { 835/// 'public bar' and 'virtual private baz' are each base-specifiers. 836/// 837/// base-specifier: [C++ class.derived] 838/// ::[opt] nested-name-specifier[opt] class-name 839/// 'virtual' access-specifier[opt] ::[opt] nested-name-specifier[opt] 840/// class-name 841/// access-specifier 'virtual'[opt] ::[opt] nested-name-specifier[opt] 842/// class-name 843Parser::BaseResult Parser::ParseBaseSpecifier(DeclPtrTy ClassDecl) { 844 bool IsVirtual = false; 845 SourceLocation StartLoc = Tok.getLocation(); 846 847 // Parse the 'virtual' keyword. 848 if (Tok.is(tok::kw_virtual)) { 849 ConsumeToken(); 850 IsVirtual = true; 851 } 852 853 // Parse an (optional) access specifier. 854 AccessSpecifier Access = getAccessSpecifierIfPresent(); 855 if (Access) 856 ConsumeToken(); 857 858 // Parse the 'virtual' keyword (again!), in case it came after the 859 // access specifier. 860 if (Tok.is(tok::kw_virtual)) { 861 SourceLocation VirtualLoc = ConsumeToken(); 862 if (IsVirtual) { 863 // Complain about duplicate 'virtual' 864 Diag(VirtualLoc, diag::err_dup_virtual) 865 << CodeModificationHint::CreateRemoval(SourceRange(VirtualLoc)); 866 } 867 868 IsVirtual = true; 869 } 870 871 // Parse optional '::' and optional nested-name-specifier. 872 CXXScopeSpec SS; 873 ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/0, true); 874 875 // The location of the base class itself. 876 SourceLocation BaseLoc = Tok.getLocation(); 877 878 // Parse the class-name. 879 SourceLocation EndLocation; 880 TypeResult BaseType = ParseClassName(EndLocation, &SS); 881 if (BaseType.isInvalid()) 882 return true; 883 884 // Find the complete source range for the base-specifier. 885 SourceRange Range(StartLoc, EndLocation); 886 887 // Notify semantic analysis that we have parsed a complete 888 // base-specifier. 889 return Actions.ActOnBaseSpecifier(ClassDecl, Range, IsVirtual, Access, 890 BaseType.get(), BaseLoc); 891} 892 893/// getAccessSpecifierIfPresent - Determine whether the next token is 894/// a C++ access-specifier. 895/// 896/// access-specifier: [C++ class.derived] 897/// 'private' 898/// 'protected' 899/// 'public' 900AccessSpecifier Parser::getAccessSpecifierIfPresent() const { 901 switch (Tok.getKind()) { 902 default: return AS_none; 903 case tok::kw_private: return AS_private; 904 case tok::kw_protected: return AS_protected; 905 case tok::kw_public: return AS_public; 906 } 907} 908 909void Parser::HandleMemberFunctionDefaultArgs(Declarator& DeclaratorInfo, 910 DeclPtrTy ThisDecl) { 911 // We just declared a member function. If this member function 912 // has any default arguments, we'll need to parse them later. 913 LateParsedMethodDeclaration *LateMethod = 0; 914 DeclaratorChunk::FunctionTypeInfo &FTI 915 = DeclaratorInfo.getTypeObject(0).Fun; 916 for (unsigned ParamIdx = 0; ParamIdx < FTI.NumArgs; ++ParamIdx) { 917 if (LateMethod || FTI.ArgInfo[ParamIdx].DefaultArgTokens) { 918 if (!LateMethod) { 919 // Push this method onto the stack of late-parsed method 920 // declarations. 921 getCurrentClass().MethodDecls.push_back( 922 LateParsedMethodDeclaration(ThisDecl)); 923 LateMethod = &getCurrentClass().MethodDecls.back(); 924 LateMethod->TemplateScope = CurScope->isTemplateParamScope(); 925 926 // Add all of the parameters prior to this one (they don't 927 // have default arguments). 928 LateMethod->DefaultArgs.reserve(FTI.NumArgs); 929 for (unsigned I = 0; I < ParamIdx; ++I) 930 LateMethod->DefaultArgs.push_back( 931 LateParsedDefaultArgument(FTI.ArgInfo[ParamIdx].Param)); 932 } 933 934 // Add this parameter to the list of parameters (it or may 935 // not have a default argument). 936 LateMethod->DefaultArgs.push_back( 937 LateParsedDefaultArgument(FTI.ArgInfo[ParamIdx].Param, 938 FTI.ArgInfo[ParamIdx].DefaultArgTokens)); 939 } 940 } 941} 942 943/// ParseCXXClassMemberDeclaration - Parse a C++ class member declaration. 944/// 945/// member-declaration: 946/// decl-specifier-seq[opt] member-declarator-list[opt] ';' 947/// function-definition ';'[opt] 948/// ::[opt] nested-name-specifier template[opt] unqualified-id ';'[TODO] 949/// using-declaration [TODO] 950/// [C++0x] static_assert-declaration 951/// template-declaration 952/// [GNU] '__extension__' member-declaration 953/// 954/// member-declarator-list: 955/// member-declarator 956/// member-declarator-list ',' member-declarator 957/// 958/// member-declarator: 959/// declarator pure-specifier[opt] 960/// declarator constant-initializer[opt] 961/// identifier[opt] ':' constant-expression 962/// 963/// pure-specifier: 964/// '= 0' 965/// 966/// constant-initializer: 967/// '=' constant-expression 968/// 969void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, 970 const ParsedTemplateInfo &TemplateInfo) { 971 // static_assert-declaration 972 if (Tok.is(tok::kw_static_assert)) { 973 // FIXME: Check for templates 974 SourceLocation DeclEnd; 975 ParseStaticAssertDeclaration(DeclEnd); 976 return; 977 } 978 979 if (Tok.is(tok::kw_template)) { 980 assert(!TemplateInfo.TemplateParams && 981 "Nested template improperly parsed?"); 982 SourceLocation DeclEnd; 983 ParseDeclarationStartingWithTemplate(Declarator::MemberContext, DeclEnd, 984 AS); 985 return; 986 } 987 988 // Handle: member-declaration ::= '__extension__' member-declaration 989 if (Tok.is(tok::kw___extension__)) { 990 // __extension__ silences extension warnings in the subexpression. 991 ExtensionRAIIObject O(Diags); // Use RAII to do this. 992 ConsumeToken(); 993 return ParseCXXClassMemberDeclaration(AS, TemplateInfo); 994 } 995 996 if (Tok.is(tok::kw_using)) { 997 // FIXME: Check for template aliases 998 999 // Eat 'using'. 1000 SourceLocation UsingLoc = ConsumeToken(); 1001 1002 if (Tok.is(tok::kw_namespace)) { 1003 Diag(UsingLoc, diag::err_using_namespace_in_class); 1004 SkipUntil(tok::semi, true, true); 1005 } 1006 else { 1007 SourceLocation DeclEnd; 1008 // Otherwise, it must be using-declaration. 1009 ParseUsingDeclaration(Declarator::MemberContext, UsingLoc, DeclEnd, AS); 1010 } 1011 return; 1012 } 1013 1014 SourceLocation DSStart = Tok.getLocation(); 1015 // decl-specifier-seq: 1016 // Parse the common declaration-specifiers piece. 1017 DeclSpec DS; 1018 ParseDeclarationSpecifiers(DS, TemplateInfo, AS, DSC_class); 1019 1020 Action::MultiTemplateParamsArg TemplateParams(Actions, 1021 TemplateInfo.TemplateParams? TemplateInfo.TemplateParams->data() : 0, 1022 TemplateInfo.TemplateParams? TemplateInfo.TemplateParams->size() : 0); 1023 1024 if (Tok.is(tok::semi)) { 1025 ConsumeToken(); 1026 1027 if (DS.isFriendSpecified()) { 1028 Actions.ActOnFriendTypeDecl(CurScope, DS, move(TemplateParams)); 1029 } else 1030 Actions.ParsedFreeStandingDeclSpec(CurScope, DS); 1031 1032 return; 1033 } 1034 1035 Declarator DeclaratorInfo(DS, Declarator::MemberContext); 1036 1037 if (Tok.isNot(tok::colon)) { 1038 // Parse the first declarator. 1039 ParseDeclarator(DeclaratorInfo); 1040 // Error parsing the declarator? 1041 if (!DeclaratorInfo.hasName()) { 1042 // If so, skip until the semi-colon or a }. 1043 SkipUntil(tok::r_brace, true); 1044 if (Tok.is(tok::semi)) 1045 ConsumeToken(); 1046 return; 1047 } 1048 1049 // function-definition: 1050 if (Tok.is(tok::l_brace) 1051 || (DeclaratorInfo.isFunctionDeclarator() && 1052 (Tok.is(tok::colon) || Tok.is(tok::kw_try)))) { 1053 if (!DeclaratorInfo.isFunctionDeclarator()) { 1054 Diag(Tok, diag::err_func_def_no_params); 1055 ConsumeBrace(); 1056 SkipUntil(tok::r_brace, true); 1057 return; 1058 } 1059 1060 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) { 1061 Diag(Tok, diag::err_function_declared_typedef); 1062 // This recovery skips the entire function body. It would be nice 1063 // to simply call ParseCXXInlineMethodDef() below, however Sema 1064 // assumes the declarator represents a function, not a typedef. 1065 ConsumeBrace(); 1066 SkipUntil(tok::r_brace, true); 1067 return; 1068 } 1069 1070 ParseCXXInlineMethodDef(AS, DeclaratorInfo, TemplateInfo); 1071 return; 1072 } 1073 } 1074 1075 // member-declarator-list: 1076 // member-declarator 1077 // member-declarator-list ',' member-declarator 1078 1079 llvm::SmallVector<DeclPtrTy, 8> DeclsInGroup; 1080 OwningExprResult BitfieldSize(Actions); 1081 OwningExprResult Init(Actions); 1082 bool Deleted = false; 1083 1084 while (1) { 1085 1086 // member-declarator: 1087 // declarator pure-specifier[opt] 1088 // declarator constant-initializer[opt] 1089 // identifier[opt] ':' constant-expression 1090 1091 if (Tok.is(tok::colon)) { 1092 ConsumeToken(); 1093 BitfieldSize = ParseConstantExpression(); 1094 if (BitfieldSize.isInvalid()) 1095 SkipUntil(tok::comma, true, true); 1096 } 1097 1098 // pure-specifier: 1099 // '= 0' 1100 // 1101 // constant-initializer: 1102 // '=' constant-expression 1103 // 1104 // defaulted/deleted function-definition: 1105 // '=' 'default' [TODO] 1106 // '=' 'delete' 1107 1108 if (Tok.is(tok::equal)) { 1109 ConsumeToken(); 1110 if (getLang().CPlusPlus0x && Tok.is(tok::kw_delete)) { 1111 ConsumeToken(); 1112 Deleted = true; 1113 } else { 1114 Init = ParseInitializer(); 1115 if (Init.isInvalid()) 1116 SkipUntil(tok::comma, true, true); 1117 } 1118 } 1119 1120 // If attributes exist after the declarator, parse them. 1121 if (Tok.is(tok::kw___attribute)) { 1122 SourceLocation Loc; 1123 AttributeList *AttrList = ParseAttributes(&Loc); 1124 DeclaratorInfo.AddAttributes(AttrList, Loc); 1125 } 1126 1127 // NOTE: If Sema is the Action module and declarator is an instance field, 1128 // this call will *not* return the created decl; It will return null. 1129 // See Sema::ActOnCXXMemberDeclarator for details. 1130 1131 DeclPtrTy ThisDecl; 1132 if (DS.isFriendSpecified()) { 1133 // TODO: handle initializers, bitfields, 'delete' 1134 ThisDecl = Actions.ActOnFriendFunctionDecl(CurScope, DeclaratorInfo, 1135 /*IsDefinition*/ false, 1136 move(TemplateParams)); 1137 } else { 1138 ThisDecl = Actions.ActOnCXXMemberDeclarator(CurScope, AS, 1139 DeclaratorInfo, 1140 move(TemplateParams), 1141 BitfieldSize.release(), 1142 Init.release(), 1143 Deleted); 1144 } 1145 if (ThisDecl) 1146 DeclsInGroup.push_back(ThisDecl); 1147 1148 if (DeclaratorInfo.isFunctionDeclarator() && 1149 DeclaratorInfo.getDeclSpec().getStorageClassSpec() 1150 != DeclSpec::SCS_typedef) { 1151 HandleMemberFunctionDefaultArgs(DeclaratorInfo, ThisDecl); 1152 } 1153 1154 // If we don't have a comma, it is either the end of the list (a ';') 1155 // or an error, bail out. 1156 if (Tok.isNot(tok::comma)) 1157 break; 1158 1159 // Consume the comma. 1160 ConsumeToken(); 1161 1162 // Parse the next declarator. 1163 DeclaratorInfo.clear(); 1164 BitfieldSize = 0; 1165 Init = 0; 1166 Deleted = false; 1167 1168 // Attributes are only allowed on the second declarator. 1169 if (Tok.is(tok::kw___attribute)) { 1170 SourceLocation Loc; 1171 AttributeList *AttrList = ParseAttributes(&Loc); 1172 DeclaratorInfo.AddAttributes(AttrList, Loc); 1173 } 1174 1175 if (Tok.isNot(tok::colon)) 1176 ParseDeclarator(DeclaratorInfo); 1177 } 1178 1179 if (Tok.is(tok::semi)) { 1180 ConsumeToken(); 1181 Actions.FinalizeDeclaratorGroup(CurScope, DS, DeclsInGroup.data(), 1182 DeclsInGroup.size()); 1183 return; 1184 } 1185 1186 Diag(Tok, diag::err_expected_semi_decl_list); 1187 // Skip to end of block or statement 1188 SkipUntil(tok::r_brace, true, true); 1189 if (Tok.is(tok::semi)) 1190 ConsumeToken(); 1191 return; 1192} 1193 1194/// ParseCXXMemberSpecification - Parse the class definition. 1195/// 1196/// member-specification: 1197/// member-declaration member-specification[opt] 1198/// access-specifier ':' member-specification[opt] 1199/// 1200void Parser::ParseCXXMemberSpecification(SourceLocation RecordLoc, 1201 unsigned TagType, DeclPtrTy TagDecl) { 1202 assert((TagType == DeclSpec::TST_struct || 1203 TagType == DeclSpec::TST_union || 1204 TagType == DeclSpec::TST_class) && "Invalid TagType!"); 1205 1206 PrettyStackTraceActionsDecl CrashInfo(TagDecl, RecordLoc, Actions, 1207 PP.getSourceManager(), 1208 "parsing struct/union/class body"); 1209 1210 SourceLocation LBraceLoc = ConsumeBrace(); 1211 1212 // Determine whether this is a top-level (non-nested) class. 1213 bool TopLevelClass = ClassStack.empty() || 1214 CurScope->isInCXXInlineMethodScope(); 1215 1216 // Enter a scope for the class. 1217 ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope); 1218 1219 // Note that we are parsing a new (potentially-nested) class definition. 1220 ParsingClassDefinition ParsingDef(*this, TagDecl, TopLevelClass); 1221 1222 if (TagDecl) 1223 Actions.ActOnTagStartDefinition(CurScope, TagDecl); 1224 else { 1225 SkipUntil(tok::r_brace, false, false); 1226 return; 1227 } 1228 1229 // C++ 11p3: Members of a class defined with the keyword class are private 1230 // by default. Members of a class defined with the keywords struct or union 1231 // are public by default. 1232 AccessSpecifier CurAS; 1233 if (TagType == DeclSpec::TST_class) 1234 CurAS = AS_private; 1235 else 1236 CurAS = AS_public; 1237 1238 // While we still have something to read, read the member-declarations. 1239 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) { 1240 // Each iteration of this loop reads one member-declaration. 1241 1242 // Check for extraneous top-level semicolon. 1243 if (Tok.is(tok::semi)) { 1244 Diag(Tok, diag::ext_extra_struct_semi); 1245 ConsumeToken(); 1246 continue; 1247 } 1248 1249 AccessSpecifier AS = getAccessSpecifierIfPresent(); 1250 if (AS != AS_none) { 1251 // Current token is a C++ access specifier. 1252 CurAS = AS; 1253 ConsumeToken(); 1254 ExpectAndConsume(tok::colon, diag::err_expected_colon); 1255 continue; 1256 } 1257 1258 // FIXME: Make sure we don't have a template here. 1259 1260 // Parse all the comma separated declarators. 1261 ParseCXXClassMemberDeclaration(CurAS); 1262 } 1263 1264 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc); 1265 1266 AttributeList *AttrList = 0; 1267 // If attributes exist after class contents, parse them. 1268 if (Tok.is(tok::kw___attribute)) 1269 AttrList = ParseAttributes(); // FIXME: where should I put them? 1270 1271 Actions.ActOnFinishCXXMemberSpecification(CurScope, RecordLoc, TagDecl, 1272 LBraceLoc, RBraceLoc); 1273 1274 // C++ 9.2p2: Within the class member-specification, the class is regarded as 1275 // complete within function bodies, default arguments, 1276 // exception-specifications, and constructor ctor-initializers (including 1277 // such things in nested classes). 1278 // 1279 // FIXME: Only function bodies and constructor ctor-initializers are 1280 // parsed correctly, fix the rest. 1281 if (TopLevelClass) { 1282 // We are not inside a nested class. This class and its nested classes 1283 // are complete and we can parse the delayed portions of method 1284 // declarations and the lexed inline method definitions. 1285 ParseLexedMethodDeclarations(getCurrentClass()); 1286 ParseLexedMethodDefs(getCurrentClass()); 1287 } 1288 1289 // Leave the class scope. 1290 ParsingDef.Pop(); 1291 ClassScope.Exit(); 1292 1293 Actions.ActOnTagFinishDefinition(CurScope, TagDecl, RBraceLoc); 1294} 1295 1296/// ParseConstructorInitializer - Parse a C++ constructor initializer, 1297/// which explicitly initializes the members or base classes of a 1298/// class (C++ [class.base.init]). For example, the three initializers 1299/// after the ':' in the Derived constructor below: 1300/// 1301/// @code 1302/// class Base { }; 1303/// class Derived : Base { 1304/// int x; 1305/// float f; 1306/// public: 1307/// Derived(float f) : Base(), x(17), f(f) { } 1308/// }; 1309/// @endcode 1310/// 1311/// [C++] ctor-initializer: 1312/// ':' mem-initializer-list 1313/// 1314/// [C++] mem-initializer-list: 1315/// mem-initializer 1316/// mem-initializer , mem-initializer-list 1317void Parser::ParseConstructorInitializer(DeclPtrTy ConstructorDecl) { 1318 assert(Tok.is(tok::colon) && "Constructor initializer always starts with ':'"); 1319 1320 SourceLocation ColonLoc = ConsumeToken(); 1321 1322 llvm::SmallVector<MemInitTy*, 4> MemInitializers; 1323 1324 do { 1325 MemInitResult MemInit = ParseMemInitializer(ConstructorDecl); 1326 if (!MemInit.isInvalid()) 1327 MemInitializers.push_back(MemInit.get()); 1328 1329 if (Tok.is(tok::comma)) 1330 ConsumeToken(); 1331 else if (Tok.is(tok::l_brace)) 1332 break; 1333 else { 1334 // Skip over garbage, until we get to '{'. Don't eat the '{'. 1335 Diag(Tok.getLocation(), diag::err_expected_lbrace_or_comma); 1336 SkipUntil(tok::l_brace, true, true); 1337 break; 1338 } 1339 } while (true); 1340 1341 Actions.ActOnMemInitializers(ConstructorDecl, ColonLoc, 1342 MemInitializers.data(), MemInitializers.size()); 1343} 1344 1345/// ParseMemInitializer - Parse a C++ member initializer, which is 1346/// part of a constructor initializer that explicitly initializes one 1347/// member or base class (C++ [class.base.init]). See 1348/// ParseConstructorInitializer for an example. 1349/// 1350/// [C++] mem-initializer: 1351/// mem-initializer-id '(' expression-list[opt] ')' 1352/// 1353/// [C++] mem-initializer-id: 1354/// '::'[opt] nested-name-specifier[opt] class-name 1355/// identifier 1356Parser::MemInitResult Parser::ParseMemInitializer(DeclPtrTy ConstructorDecl) { 1357 // parse '::'[opt] nested-name-specifier[opt] 1358 CXXScopeSpec SS; 1359 ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/0, false); 1360 TypeTy *TemplateTypeTy = 0; 1361 if (Tok.is(tok::annot_template_id)) { 1362 TemplateIdAnnotation *TemplateId 1363 = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue()); 1364 if (TemplateId->Kind == TNK_Type_template) { 1365 AnnotateTemplateIdTokenAsType(&SS); 1366 assert(Tok.is(tok::annot_typename) && "template-id -> type failed"); 1367 TemplateTypeTy = Tok.getAnnotationValue(); 1368 } 1369 // FIXME. May need to check for TNK_Dependent_template as well. 1370 } 1371 if (!TemplateTypeTy && Tok.isNot(tok::identifier)) { 1372 Diag(Tok, diag::err_expected_member_or_base_name); 1373 return true; 1374 } 1375 1376 // Get the identifier. This may be a member name or a class name, 1377 // but we'll let the semantic analysis determine which it is. 1378 IdentifierInfo *II = Tok.is(tok::identifier) ? Tok.getIdentifierInfo() : 0; 1379 SourceLocation IdLoc = ConsumeToken(); 1380 1381 // Parse the '('. 1382 if (Tok.isNot(tok::l_paren)) { 1383 Diag(Tok, diag::err_expected_lparen); 1384 return true; 1385 } 1386 SourceLocation LParenLoc = ConsumeParen(); 1387 1388 // Parse the optional expression-list. 1389 ExprVector ArgExprs(Actions); 1390 CommaLocsTy CommaLocs; 1391 if (Tok.isNot(tok::r_paren) && ParseExpressionList(ArgExprs, CommaLocs)) { 1392 SkipUntil(tok::r_paren); 1393 return true; 1394 } 1395 1396 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 1397 1398 return Actions.ActOnMemInitializer(ConstructorDecl, CurScope, SS, II, 1399 TemplateTypeTy, IdLoc, 1400 LParenLoc, ArgExprs.take(), 1401 ArgExprs.size(), CommaLocs.data(), 1402 RParenLoc); 1403} 1404 1405/// ParseExceptionSpecification - Parse a C++ exception-specification 1406/// (C++ [except.spec]). 1407/// 1408/// exception-specification: 1409/// 'throw' '(' type-id-list [opt] ')' 1410/// [MS] 'throw' '(' '...' ')' 1411/// 1412/// type-id-list: 1413/// type-id 1414/// type-id-list ',' type-id 1415/// 1416bool Parser::ParseExceptionSpecification(SourceLocation &EndLoc, 1417 llvm::SmallVector<TypeTy*, 2> 1418 &Exceptions, 1419 llvm::SmallVector<SourceRange, 2> 1420 &Ranges, 1421 bool &hasAnyExceptionSpec) { 1422 assert(Tok.is(tok::kw_throw) && "expected throw"); 1423 1424 SourceLocation ThrowLoc = ConsumeToken(); 1425 1426 if (!Tok.is(tok::l_paren)) { 1427 return Diag(Tok, diag::err_expected_lparen_after) << "throw"; 1428 } 1429 SourceLocation LParenLoc = ConsumeParen(); 1430 1431 // Parse throw(...), a Microsoft extension that means "this function 1432 // can throw anything". 1433 if (Tok.is(tok::ellipsis)) { 1434 hasAnyExceptionSpec = true; 1435 SourceLocation EllipsisLoc = ConsumeToken(); 1436 if (!getLang().Microsoft) 1437 Diag(EllipsisLoc, diag::ext_ellipsis_exception_spec); 1438 EndLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 1439 return false; 1440 } 1441 1442 // Parse the sequence of type-ids. 1443 SourceRange Range; 1444 while (Tok.isNot(tok::r_paren)) { 1445 TypeResult Res(ParseTypeName(&Range)); 1446 if (!Res.isInvalid()) { 1447 Exceptions.push_back(Res.get()); 1448 Ranges.push_back(Range); 1449 } 1450 if (Tok.is(tok::comma)) 1451 ConsumeToken(); 1452 else 1453 break; 1454 } 1455 1456 EndLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 1457 return false; 1458} 1459 1460/// \brief We have just started parsing the definition of a new class, 1461/// so push that class onto our stack of classes that is currently 1462/// being parsed. 1463void Parser::PushParsingClass(DeclPtrTy ClassDecl, bool TopLevelClass) { 1464 assert((TopLevelClass || !ClassStack.empty()) && 1465 "Nested class without outer class"); 1466 ClassStack.push(new ParsingClass(ClassDecl, TopLevelClass)); 1467} 1468 1469/// \brief Deallocate the given parsed class and all of its nested 1470/// classes. 1471void Parser::DeallocateParsedClasses(Parser::ParsingClass *Class) { 1472 for (unsigned I = 0, N = Class->NestedClasses.size(); I != N; ++I) 1473 DeallocateParsedClasses(Class->NestedClasses[I]); 1474 delete Class; 1475} 1476 1477/// \brief Pop the top class of the stack of classes that are 1478/// currently being parsed. 1479/// 1480/// This routine should be called when we have finished parsing the 1481/// definition of a class, but have not yet popped the Scope 1482/// associated with the class's definition. 1483/// 1484/// \returns true if the class we've popped is a top-level class, 1485/// false otherwise. 1486void Parser::PopParsingClass() { 1487 assert(!ClassStack.empty() && "Mismatched push/pop for class parsing"); 1488 1489 ParsingClass *Victim = ClassStack.top(); 1490 ClassStack.pop(); 1491 if (Victim->TopLevelClass) { 1492 // Deallocate all of the nested classes of this class, 1493 // recursively: we don't need to keep any of this information. 1494 DeallocateParsedClasses(Victim); 1495 return; 1496 } 1497 assert(!ClassStack.empty() && "Missing top-level class?"); 1498 1499 if (Victim->MethodDecls.empty() && Victim->MethodDefs.empty() && 1500 Victim->NestedClasses.empty()) { 1501 // The victim is a nested class, but we will not need to perform 1502 // any processing after the definition of this class since it has 1503 // no members whose handling was delayed. Therefore, we can just 1504 // remove this nested class. 1505 delete Victim; 1506 return; 1507 } 1508 1509 // This nested class has some members that will need to be processed 1510 // after the top-level class is completely defined. Therefore, add 1511 // it to the list of nested classes within its parent. 1512 assert(CurScope->isClassScope() && "Nested class outside of class scope?"); 1513 ClassStack.top()->NestedClasses.push_back(Victim); 1514 Victim->TemplateScope = CurScope->getParent()->isTemplateParamScope(); 1515} 1516