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