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